1 /*

     2  * Copyright (c) 2013, 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 8004867

    28  * @summary VM crashing with assert "share/vm/opto/node.hpp:357 - assert(i < _max) failed: oob"

    29  *

    30  * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-OptimizeFill TestIntAtomicOrdered

    31  * @run main/othervm/timeout=300 -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:+OptimizeFill TestIntAtomicOrdered

    32  */

    33 

    34 import java.util.concurrent.atomic.AtomicIntegerArray;

    35 

    36 public class TestIntAtomicOrdered {

    37   private static final int ARRLEN = 97;

    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 Integer array atomic ordered operations");

    46     int errn = test(false);

    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(boolean test_only) {

    55     AtomicIntegerArray a1 = new AtomicIntegerArray(ARRLEN);

    56     AtomicIntegerArray a2 = new AtomicIntegerArray(ARRLEN);

    57     // Initialize

    58     for (int i=0; i<ARRLEN; i++) {

    59       a1.lazySet(i, -1);

    60       a2.lazySet(i, -1);

    61     }

    62     System.out.println("Warmup");

    63     for (int i=0; i<ITERS; i++) {

    64       test_ci(a1);

    65       test_vi(a2, 123, -1);

    66       test_cp(a1, a2);

    67       test_2ci(a1, a2);

    68       test_2vi(a1, a2, 123, 103);

    69       test_ci_neg(a1, 123);

    70       test_vi_neg(a2, 123, 103);

    71       test_cp_neg(a1, a2);

    72       test_2ci_neg(a1, a2);

    73       test_2vi_neg(a1, a2, 123, 103);

    74       test_ci_oppos(a1, 123);

    75       test_vi_oppos(a2, 123, 103);

    76       test_cp_oppos(a1, a2);

    77       test_2ci_oppos(a1, a2);

    78       test_2vi_oppos(a1, a2, 123, 103);

    79       test_ci_off(a1, 123);

    80       test_vi_off(a2, 123, 103);

    81       test_cp_off(a1, a2);

    82       test_2ci_off(a1, a2);

    83       test_2vi_off(a1, a2, 123, 103);

    84       test_ci_inv(a1, OFFSET, 123);

    85       test_vi_inv(a2, 123, OFFSET, 103);

    86       test_cp_inv(a1, a2, OFFSET);

    87       test_2ci_inv(a1, a2, OFFSET);

    88       test_2vi_inv(a1, a2, 123, 103, OFFSET);

    89       test_ci_scl(a1, 123);

    90       test_vi_scl(a2, 123, 103);

    91       test_cp_scl(a1, a2);

    92       test_2ci_scl(a1, a2);

    93       test_2vi_scl(a1, a2, 123, 103);

    94       test_cp_alndst(a1, a2);

    95       test_cp_alnsrc(a1, a2);

    96       test_2ci_aln(a1, a2);

    97       test_2vi_aln(a1, a2, 123, 103);

    98       test_cp_unalndst(a1, a2);

    99       test_cp_unalnsrc(a1, a2);

   100       test_2ci_unaln(a1, a2);

   101       test_2vi_unaln(a1, a2, 123, 103);

   102     }

   103     // Initialize

   104     for (int i=0; i<ARRLEN; i++) {

   105       a1.lazySet(i, -1);

   106       a2.lazySet(i, -1);

   107     }

   108     // Test and verify results

   109     System.out.println("Verification");

   110     int errn = 0;

   111     {

   112       test_ci(a1);

   113       for (int i=0; i<ARRLEN; i++) {

   114         errn += verify("test_ci: a1", i, a1.get(i), -123);

   115       }

   116       test_vi(a2, 123, -1);

   117       for (int i=0; i<ARRLEN; i++) {

   118         errn += verify("test_vi: a2", i, a2.get(i), 123);

   119       }

   120       test_cp(a1, a2);

   121       for (int i=0; i<ARRLEN; i++) {

   122         errn += verify("test_cp: a1", i, a1.get(i), 123);

   123       }

   124       test_2ci(a1, a2);

   125       for (int i=0; i<ARRLEN; i++) {

   126         errn += verify("test_2ci: a1", i, a1.get(i), -123);

   127         errn += verify("test_2ci: a2", i, a2.get(i), -103);

   128       }

   129       test_2vi(a1, a2, 123, 103);

   130       for (int i=0; i<ARRLEN; i++) {

   131         errn += verify("test_2vi: a1", i, a1.get(i), 123);

   132         errn += verify("test_2vi: a2", i, a2.get(i), 103);

   133       }

   134       // Reset for negative stride

   135       for (int i=0; i<ARRLEN; i++) {

   136         a1.lazySet(i, -1);

   137         a2.lazySet(i, -1);

   138       }

   139       test_ci_neg(a1, -1);

   140       for (int i=0; i<ARRLEN; i++) {

   141         errn += verify("test_ci_neg: a1", i, a1.get(i), -123);

   142       }

   143       test_vi_neg(a2, 123, -1);

   144       for (int i=0; i<ARRLEN; i++) {

   145         errn += verify("test_vi_neg: a2", i, a2.get(i), 123);

   146       }

   147       test_cp_neg(a1, a2);

   148       for (int i=0; i<ARRLEN; i++) {

   149         errn += verify("test_cp_neg: a1", i, a1.get(i), 123);

   150       }

   151       test_2ci_neg(a1, a2);

   152       for (int i=0; i<ARRLEN; i++) {

   153         errn += verify("test_2ci_neg: a1", i, a1.get(i), -123);

   154         errn += verify("test_2ci_neg: a2", i, a2.get(i), -103);

   155       }

   156       test_2vi_neg(a1, a2, 123, 103);

   157       for (int i=0; i<ARRLEN; i++) {

   158         errn += verify("test_2vi_neg: a1", i, a1.get(i), 123);

   159         errn += verify("test_2vi_neg: a2", i, a2.get(i), 103);

   160       }

   161       // Reset for opposite stride

   162       for (int i=0; i<ARRLEN; i++) {

   163         a1.lazySet(i, -1);

   164         a2.lazySet(i, -1);

   165       }

   166       test_ci_oppos(a1, -1);

   167       for (int i=0; i<ARRLEN; i++) {

   168         errn += verify("test_ci_oppos: a1", i, a1.get(i), -123);

   169       }

   170       test_vi_oppos(a2, 123, -1);

   171       for (int i=0; i<ARRLEN; i++) {

   172         errn += verify("test_vi_oppos: a2", i, a2.get(i), 123);

   173       }

   174       test_cp_oppos(a1, a2);

   175       for (int i=0; i<ARRLEN; i++) {

   176         errn += verify("test_cp_oppos: a1", i, a1.get(i), 123);

   177       }

   178       test_2ci_oppos(a1, a2);

   179       for (int i=0; i<ARRLEN; i++) {

   180         errn += verify("test_2ci_oppos: a1", i, a1.get(i), -123);

   181         errn += verify("test_2ci_oppos: a2", i, a2.get(i), -103);

   182       }

   183       test_2vi_oppos(a1, a2, 123, 103);

   184       for (int i=0; i<ARRLEN; i++) {

   185         errn += verify("test_2vi_oppos: a1", i, a1.get(i), 123);

   186         errn += verify("test_2vi_oppos: a2", i, a2.get(i), 103);

   187       }

   188       // Reset for indexing with offset

   189       for (int i=0; i<ARRLEN; i++) {

   190         a1.lazySet(i, -1);

   191         a2.lazySet(i, -1);

   192       }

   193       test_ci_off(a1, -1);

   194       for (int i=OFFSET; i<ARRLEN; i++) {

   195         errn += verify("test_ci_off: a1", i, a1.get(i), -123);

   196       }

   197       test_vi_off(a2, 123, -1);

   198       for (int i=OFFSET; i<ARRLEN; i++) {

   199         errn += verify("test_vi_off: a2", i, a2.get(i), 123);

   200       }

   201       test_cp_off(a1, a2);

   202       for (int i=OFFSET; i<ARRLEN; i++) {

   203         errn += verify("test_cp_off: a1", i, a1.get(i), 123);

   204       }

   205       test_2ci_off(a1, a2);

   206       for (int i=OFFSET; i<ARRLEN; i++) {

   207         errn += verify("test_2ci_off: a1", i, a1.get(i), -123);

   208         errn += verify("test_2ci_off: a2", i, a2.get(i), -103);

   209       }

   210       test_2vi_off(a1, a2, 123, 103);

   211       for (int i=OFFSET; i<ARRLEN; i++) {

   212         errn += verify("test_2vi_off: a1", i, a1.get(i), 123);

   213         errn += verify("test_2vi_off: a2", i, a2.get(i), 103);

   214       }

   215       for (int i=0; i<OFFSET; i++) {

   216         errn += verify("test_2vi_off: a1", i, a1.get(i), -1);

   217         errn += verify("test_2vi_off: a2", i, a2.get(i), -1);

   218       }

   219       // Reset for indexing with invariant offset

   220       for (int i=0; i<ARRLEN; i++) {

   221         a1.lazySet(i, -1);

   222         a2.lazySet(i, -1);

   223       }

   224       test_ci_inv(a1, OFFSET, -1);

   225       for (int i=OFFSET; i<ARRLEN; i++) {

   226         errn += verify("test_ci_inv: a1", i, a1.get(i), -123);

   227       }

   228       test_vi_inv(a2, 123, OFFSET, -1);

   229       for (int i=OFFSET; i<ARRLEN; i++) {

   230         errn += verify("test_vi_inv: a2", i, a2.get(i), 123);

   231       }

   232       test_cp_inv(a1, a2, OFFSET);

   233       for (int i=OFFSET; i<ARRLEN; i++) {

   234         errn += verify("test_cp_inv: a1", i, a1.get(i), 123);

   235       }

   236       test_2ci_inv(a1, a2, OFFSET);

   237       for (int i=OFFSET; i<ARRLEN; i++) {

   238         errn += verify("test_2ci_inv: a1", i, a1.get(i), -123);

   239         errn += verify("test_2ci_inv: a2", i, a2.get(i), -103);

   240       }

   241       test_2vi_inv(a1, a2, 123, 103, OFFSET);

   242       for (int i=OFFSET; i<ARRLEN; i++) {

   243         errn += verify("test_2vi_inv: a1", i, a1.get(i), 123);

   244         errn += verify("test_2vi_inv: a2", i, a2.get(i), 103);

   245       }

   246       for (int i=0; i<OFFSET; i++) {

   247         errn += verify("test_2vi_inv: a1", i, a1.get(i), -1);

   248         errn += verify("test_2vi_inv: a2", i, a2.get(i), -1);

   249       }

   250       // Reset for indexing with scale

   251       for (int i=0; i<ARRLEN; i++) {

   252         a1.lazySet(i, -1);

   253         a2.lazySet(i, -1);

   254       }

   255       test_ci_scl(a1, -1);

   256       for (int i=0; i<ARRLEN; i++) {

   257         int val = (i%SCALE != 0) ? -1 : -123;

   258         errn += verify("test_ci_scl: a1", i, a1.get(i), val);

   259       }

   260       test_vi_scl(a2, 123, -1);

   261       for (int i=0; i<ARRLEN; i++) {

   262         int val = (i%SCALE != 0) ? -1 : 123;

   263         errn += verify("test_vi_scl: a2", i, a2.get(i), val);

   264       }

   265       test_cp_scl(a1, a2);

   266       for (int i=0; i<ARRLEN; i++) {

   267         int val = (i%SCALE != 0) ? -1 : 123;

   268         errn += verify("test_cp_scl: a1", i, a1.get(i), val);

   269       }

   270       test_2ci_scl(a1, a2);

   271       for (int i=0; i<ARRLEN; i++) {

   272         if (i%SCALE != 0) {

   273           errn += verify("test_2ci_scl: a1", i, a1.get(i), -1);

   274         } else if (i*SCALE < ARRLEN) {

   275           errn += verify("test_2ci_scl: a1", i*SCALE, a1.get(i*SCALE), -123);

   276         }

   277         if (i%SCALE != 0) {

   278           errn += verify("test_2ci_scl: a2", i, a2.get(i), -1);

   279         } else if (i*SCALE < ARRLEN) {

   280           errn += verify("test_2ci_scl: a2", i*SCALE, a2.get(i*SCALE), -103);

   281         }

   282       }

   283       test_2vi_scl(a1, a2, 123, 103);

   284       for (int i=0; i<ARRLEN; i++) {

   285         if (i%SCALE != 0) {

   286           errn += verify("test_2vi_scl: a1", i, a1.get(i), -1);

   287         } else if (i*SCALE < ARRLEN) {

   288           errn += verify("test_2vi_scl: a1", i*SCALE, a1.get(i*SCALE), 123);

   289         }

   290         if (i%SCALE != 0) {

   291           errn += verify("test_2vi_scl: a2", i, a2.get(i), -1);

   292         } else if (i*SCALE < ARRLEN) {

   293           errn += verify("test_2vi_scl: a2", i*SCALE, a2.get(i*SCALE), 103);

   294         }

   295       }

   296       // Reset for 2 arrays with relative aligned offset

   297       for (int i=0; i<ARRLEN; i++) {

   298         a1.lazySet(i, -1);

   299         a2.lazySet(i, -1);

   300       }

   301       test_vi(a2, 123, -1);

   302       test_cp_alndst(a1, a2);

   303       for (int i=0; i<ALIGN_OFF; i++) {

   304         errn += verify("test_cp_alndst: a1", i, a1.get(i), -1);

   305       }

   306       for (int i=ALIGN_OFF; i<ARRLEN; i++) {

   307         errn += verify("test_cp_alndst: a1", i, a1.get(i), 123);

   308       }

   309       for (int i=0; i<ALIGN_OFF; i++) {

   310         a1.lazySet(i, 123);

   311       }

   312       test_vi(a2, -123, 123);

   313       test_cp_alnsrc(a1, a2);

   314       for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {

   315         errn += verify("test_cp_alnsrc: a1", i, a1.get(i), -123);

   316       }

   317       for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {

   318         errn += verify("test_cp_alnsrc: a1", i, a1.get(i), 123);

   319       }

   320       for (int i=0; i<ARRLEN; i++) {

   321         a1.lazySet(i, -1);

   322         a2.lazySet(i, -1);

   323       }

   324       test_2ci_aln(a1, a2);

   325       for (int i=0; i<ALIGN_OFF; i++) {

   326         errn += verify("test_2ci_aln: a1", i, a1.get(i), -1);

   327       }

   328       for (int i=ALIGN_OFF; i<ARRLEN; i++) {

   329         errn += verify("test_2ci_aln: a1", i, a1.get(i), -123);

   330       }

   331       for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {

   332         errn += verify("test_2ci_aln: a2", i, a2.get(i), -103);

   333       }

   334       for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {

   335         errn += verify("test_2ci_aln: a2", i, a2.get(i), -1);

   336       }

   337       for (int i=0; i<ARRLEN; i++) {

   338         a1.lazySet(i, -1);

   339         a2.lazySet(i, -1);

   340       }

   341       test_2vi_aln(a1, a2, 123, 103);

   342       for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {

   343         errn += verify("test_2vi_aln: a1", i, a1.get(i), 123);

   344       }

   345       for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {

   346         errn += verify("test_2vi_aln: a1", i, a1.get(i), -1);

   347       }

   348       for (int i=0; i<ALIGN_OFF; i++) {

   349         errn += verify("test_2vi_aln: a2", i, a2.get(i), -1);

   350       }

   351       for (int i=ALIGN_OFF; i<ARRLEN; i++) {

   352         errn += verify("test_2vi_aln: a2", i, a2.get(i), 103);

   353       }

   354 

   355       // Reset for 2 arrays with relative unaligned offset

   356       for (int i=0; i<ARRLEN; i++) {

   357         a1.lazySet(i, -1);

   358         a2.lazySet(i, -1);

   359       }

   360       test_vi(a2, 123, -1);

   361       test_cp_unalndst(a1, a2);

   362       for (int i=0; i<UNALIGN_OFF; i++) {

   363         errn += verify("test_cp_unalndst: a1", i, a1.get(i), -1);

   364       }

   365       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {

   366         errn += verify("test_cp_unalndst: a1", i, a1.get(i), 123);

   367       }

   368       test_vi(a2, -123, 123);

   369       test_cp_unalnsrc(a1, a2);

   370       for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {

   371         errn += verify("test_cp_unalnsrc: a1", i, a1.get(i), -123);

   372       }

   373       for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {

   374         errn += verify("test_cp_unalnsrc: a1", i, a1.get(i), 123);

   375       }

   376       for (int i=0; i<ARRLEN; i++) {

   377         a1.lazySet(i, -1);

   378         a2.lazySet(i, -1);

   379       }

   380       test_2ci_unaln(a1, a2);

   381       for (int i=0; i<UNALIGN_OFF; i++) {

   382         errn += verify("test_2ci_unaln: a1", i, a1.get(i), -1);

   383       }

   384       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {

   385         errn += verify("test_2ci_unaln: a1", i, a1.get(i), -123);

   386       }

   387       for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {

   388         errn += verify("test_2ci_unaln: a2", i, a2.get(i), -103);

   389       }

   390       for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {

   391         errn += verify("test_2ci_unaln: a2", i, a2.get(i), -1);

   392       }

   393       for (int i=0; i<ARRLEN; i++) {

   394         a1.lazySet(i, -1);

   395         a2.lazySet(i, -1);

   396       }

   397       test_2vi_unaln(a1, a2, 123, 103);

   398       for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {

   399         errn += verify("test_2vi_unaln: a1", i, a1.get(i), 123);

   400       }

   401       for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {

   402         errn += verify("test_2vi_unaln: a1", i, a1.get(i), -1);

   403       }

   404       for (int i=0; i<UNALIGN_OFF; i++) {

   405         errn += verify("test_2vi_unaln: a2", i, a2.get(i), -1);

   406       }

   407       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {

   408         errn += verify("test_2vi_unaln: a2", i, a2.get(i), 103);

   409       }

   410 

   411       // Reset for aligned overlap initialization

   412       for (int i=0; i<ALIGN_OFF; i++) {

   413         a1.lazySet(i, i);

   414       }

   415       for (int i=ALIGN_OFF; i<ARRLEN; i++) {

   416         a1.lazySet(i, -1);

   417       }

   418       test_cp_alndst(a1, a1);

   419       for (int i=0; i<ARRLEN; i++) {

   420         int v = i%ALIGN_OFF;

   421         errn += verify("test_cp_alndst_overlap: a1", i, a1.get(i), v);

   422       }

   423       for (int i=0; i<ALIGN_OFF; i++) {

   424         a1.lazySet((i+ALIGN_OFF), -1);

   425       }

   426       test_cp_alnsrc(a1, a1);

   427       for (int i=0; i<ALIGN_OFF; i++) {

   428         errn += verify("test_cp_alnsrc_overlap: a1", i, a1.get(i), -1);

   429       }

   430       for (int i=ALIGN_OFF; i<ARRLEN; i++) {

   431         int v = i%ALIGN_OFF;

   432         errn += verify("test_cp_alnsrc_overlap: a1", i, a1.get(i), v);

   433       }

   434       for (int i=0; i<ARRLEN; i++) {

   435         a1.lazySet(i, -1);

   436       }

   437       test_2ci_aln(a1, a1);

   438       for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {

   439         errn += verify("test_2ci_aln_overlap: a1", i, a1.get(i), -103);

   440       }

   441       for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {

   442         errn += verify("test_2ci_aln_overlap: a1", i, a1.get(i), -123);

   443       }

   444       for (int i=0; i<ARRLEN; i++) {

   445         a1.lazySet(i, -1);

   446       }

   447       test_2vi_aln(a1, a1, 123, 103);

   448       for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {

   449         errn += verify("test_2vi_aln_overlap: a1", i, a1.get(i), 123);

   450       }

   451       for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {

   452         errn += verify("test_2vi_aln_overlap: a1", i, a1.get(i), 103);

   453       }

   454 

   455       // Reset for unaligned overlap initialization

   456       for (int i=0; i<UNALIGN_OFF; i++) {

   457         a1.lazySet(i, i);

   458       }

   459       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {

   460         a1.lazySet(i, -1);

   461       }

   462       test_cp_unalndst(a1, a1);

   463       for (int i=0; i<ARRLEN; i++) {

   464         int v = i%UNALIGN_OFF;

   465         errn += verify("test_cp_unalndst_overlap: a1", i, a1.get(i), v);

   466       }

   467       for (int i=0; i<UNALIGN_OFF; i++) {

   468         a1.lazySet((i+UNALIGN_OFF), -1);

   469       }

   470       test_cp_unalnsrc(a1, a1);

   471       for (int i=0; i<UNALIGN_OFF; i++) {

   472         errn += verify("test_cp_unalnsrc_overlap: a1", i, a1.get(i), -1);

   473       }

   474       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {

   475         int v = i%UNALIGN_OFF;

   476         errn += verify("test_cp_unalnsrc_overlap: a1", i, a1.get(i), v);

   477       }

   478       for (int i=0; i<ARRLEN; i++) {

   479         a1.lazySet(i, -1);

   480       }

   481       test_2ci_unaln(a1, a1);

   482       for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {

   483         errn += verify("test_2ci_unaln_overlap: a1", i, a1.get(i), -103);

   484       }

   485       for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {

   486         errn += verify("test_2ci_unaln_overlap: a1", i, a1.get(i), -123);

   487       }

   488       for (int i=0; i<ARRLEN; i++) {

   489         a1.lazySet(i, -1);

   490       }

   491       test_2vi_unaln(a1, a1, 123, 103);

   492       for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {

   493         errn += verify("test_2vi_unaln_overlap: a1", i, a1.get(i), 123);

   494       }

   495       for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {

   496         errn += verify("test_2vi_unaln_overlap: a1", i, a1.get(i), 103);

   497       }

   498 

   499     }

   500 

   501     if (errn > 0 || test_only)

   502       return errn;

   503 

   504     // Initialize

   505     for (int i=0; i<ARRLEN; i++) {

   506       a1.lazySet(i, -1);

   507       a2.lazySet(i, -1);

   508     }

   509     System.out.println("Time");

   510     long start, end;

   511     start = System.currentTimeMillis();

   512     for (int i=0; i<ITERS; i++) {

   513       test_ci(a1);

   514     }

   515     end = System.currentTimeMillis();

   516     System.out.println("test_ci: " + (end - start));

   517     start = System.currentTimeMillis();

   518     for (int i=0; i<ITERS; i++) {

   519       test_vi(a2, 123, -1);

   520     }

   521     end = System.currentTimeMillis();

   522     System.out.println("test_vi: " + (end - start));

   523     start = System.currentTimeMillis();

   524     for (int i=0; i<ITERS; i++) {

   525       test_cp(a1, a2);

   526     }

   527     end = System.currentTimeMillis();

   528     System.out.println("test_cp: " + (end - start));

   529     start = System.currentTimeMillis();

   530     for (int i=0; i<ITERS; i++) {

   531       test_2ci(a1, a2);

   532     }

   533     end = System.currentTimeMillis();

   534     System.out.println("test_2ci: " + (end - start));

   535     start = System.currentTimeMillis();

   536     for (int i=0; i<ITERS; i++) {

   537       test_2vi(a1, a2, 123, 103);

   538     }

   539     end = System.currentTimeMillis();

   540     System.out.println("test_2vi: " + (end - start));

   541 

   542     start = System.currentTimeMillis();

   543     for (int i=0; i<ITERS; i++) {

   544       test_ci_neg(a1, 123);

   545     }

   546     end = System.currentTimeMillis();

   547     System.out.println("test_ci_neg: " + (end - start));

   548     start = System.currentTimeMillis();

   549     for (int i=0; i<ITERS; i++) {

   550       test_vi_neg(a2, 123, 103);

   551     }

   552     end = System.currentTimeMillis();

   553     System.out.println("test_vi_neg: " + (end - start));

   554     start = System.currentTimeMillis();

   555     for (int i=0; i<ITERS; i++) {

   556       test_cp_neg(a1, a2);

   557     }

   558     end = System.currentTimeMillis();

   559     System.out.println("test_cp_neg: " + (end - start));

   560     start = System.currentTimeMillis();

   561     for (int i=0; i<ITERS; i++) {

   562       test_2ci_neg(a1, a2);

   563     }

   564     end = System.currentTimeMillis();

   565     System.out.println("test_2ci_neg: " + (end - start));

   566     start = System.currentTimeMillis();

   567     for (int i=0; i<ITERS; i++) {

   568       test_2vi_neg(a1, a2, 123, 103);

   569     }

   570     end = System.currentTimeMillis();

   571     System.out.println("test_2vi_neg: " + (end - start));

   572 

   573     start = System.currentTimeMillis();

   574     for (int i=0; i<ITERS; i++) {

   575       test_ci_oppos(a1, 123);

   576     }

   577     end = System.currentTimeMillis();

   578     System.out.println("test_ci_oppos: " + (end - start));

   579     start = System.currentTimeMillis();

   580     for (int i=0; i<ITERS; i++) {

   581       test_vi_oppos(a2, 123, 103);

   582     }

   583     end = System.currentTimeMillis();

   584     System.out.println("test_vi_oppos: " + (end - start));

   585     start = System.currentTimeMillis();

   586     for (int i=0; i<ITERS; i++) {

   587       test_cp_oppos(a1, a2);

   588     }

   589     end = System.currentTimeMillis();

   590     System.out.println("test_cp_oppos: " + (end - start));

   591     start = System.currentTimeMillis();

   592     for (int i=0; i<ITERS; i++) {

   593       test_2ci_oppos(a1, a2);

   594     }

   595     end = System.currentTimeMillis();

   596     System.out.println("test_2ci_oppos: " + (end - start));

   597     start = System.currentTimeMillis();

   598     for (int i=0; i<ITERS; i++) {

   599       test_2vi_oppos(a1, a2, 123, 103);

   600     }

   601     end = System.currentTimeMillis();

   602     System.out.println("test_2vi_oppos: " + (end - start));

   603 

   604     start = System.currentTimeMillis();

   605     for (int i=0; i<ITERS; i++) {

   606       test_ci_off(a1, 123);

   607     }

   608     end = System.currentTimeMillis();

   609     System.out.println("test_ci_off: " + (end - start));

   610     start = System.currentTimeMillis();

   611     for (int i=0; i<ITERS; i++) {

   612       test_vi_off(a2, 123, 103);

   613     }

   614     end = System.currentTimeMillis();

   615     System.out.println("test_vi_off: " + (end - start));

   616     start = System.currentTimeMillis();

   617     for (int i=0; i<ITERS; i++) {

   618       test_cp_off(a1, a2);

   619     }

   620     end = System.currentTimeMillis();

   621     System.out.println("test_cp_off: " + (end - start));

   622     start = System.currentTimeMillis();

   623     for (int i=0; i<ITERS; i++) {

   624       test_2ci_off(a1, a2);

   625     }

   626     end = System.currentTimeMillis();

   627     System.out.println("test_2ci_off: " + (end - start));

   628     start = System.currentTimeMillis();

   629     for (int i=0; i<ITERS; i++) {

   630       test_2vi_off(a1, a2, 123, 103);

   631     }

   632     end = System.currentTimeMillis();

   633     System.out.println("test_2vi_off: " + (end - start));

   634 

   635     start = System.currentTimeMillis();

   636     for (int i=0; i<ITERS; i++) {

   637       test_ci_inv(a1, OFFSET, 123);

   638     }

   639     end = System.currentTimeMillis();

   640     System.out.println("test_ci_inv: " + (end - start));

   641     start = System.currentTimeMillis();

   642     for (int i=0; i<ITERS; i++) {

   643       test_vi_inv(a2, 123, OFFSET, 103);

   644     }

   645     end = System.currentTimeMillis();

   646     System.out.println("test_vi_inv: " + (end - start));

   647     start = System.currentTimeMillis();

   648     for (int i=0; i<ITERS; i++) {

   649       test_cp_inv(a1, a2, OFFSET);

   650     }

   651     end = System.currentTimeMillis();

   652     System.out.println("test_cp_inv: " + (end - start));

   653     start = System.currentTimeMillis();

   654     for (int i=0; i<ITERS; i++) {

   655       test_2ci_inv(a1, a2, OFFSET);

   656     }

   657     end = System.currentTimeMillis();

   658     System.out.println("test_2ci_inv: " + (end - start));

   659     start = System.currentTimeMillis();

   660     for (int i=0; i<ITERS; i++) {

   661       test_2vi_inv(a1, a2, 123, 103, OFFSET);

   662     }

   663     end = System.currentTimeMillis();

   664     System.out.println("test_2vi_inv: " + (end - start));

   665 

   666     start = System.currentTimeMillis();

   667     for (int i=0; i<ITERS; i++) {

   668       test_ci_scl(a1, 123);

   669     }

   670     end = System.currentTimeMillis();

   671     System.out.println("test_ci_scl: " + (end - start));

   672     start = System.currentTimeMillis();

   673     for (int i=0; i<ITERS; i++) {

   674       test_vi_scl(a2, 123, 103);

   675     }

   676     end = System.currentTimeMillis();

   677     System.out.println("test_vi_scl: " + (end - start));

   678     start = System.currentTimeMillis();

   679     for (int i=0; i<ITERS; i++) {

   680       test_cp_scl(a1, a2);

   681     }

   682     end = System.currentTimeMillis();

   683     System.out.println("test_cp_scl: " + (end - start));

   684     start = System.currentTimeMillis();

   685     for (int i=0; i<ITERS; i++) {

   686       test_2ci_scl(a1, a2);

   687     }

   688     end = System.currentTimeMillis();

   689     System.out.println("test_2ci_scl: " + (end - start));

   690     start = System.currentTimeMillis();

   691     for (int i=0; i<ITERS; i++) {

   692       test_2vi_scl(a1, a2, 123, 103);

   693     }

   694     end = System.currentTimeMillis();

   695     System.out.println("test_2vi_scl: " + (end - start));

   696 

   697     start = System.currentTimeMillis();

   698     for (int i=0; i<ITERS; i++) {

   699       test_cp_alndst(a1, a2);

   700     }

   701     end = System.currentTimeMillis();

   702     System.out.println("test_cp_alndst: " + (end - start));

   703     start = System.currentTimeMillis();

   704     for (int i=0; i<ITERS; i++) {

   705       test_cp_alnsrc(a1, a2);

   706     }

   707     end = System.currentTimeMillis();

   708     System.out.println("test_cp_alnsrc: " + (end - start));

   709     start = System.currentTimeMillis();

   710     for (int i=0; i<ITERS; i++) {

   711       test_2ci_aln(a1, a2);

   712     }

   713     end = System.currentTimeMillis();

   714     System.out.println("test_2ci_aln: " + (end - start));

   715     start = System.currentTimeMillis();

   716     for (int i=0; i<ITERS; i++) {

   717       test_2vi_aln(a1, a2, 123, 103);

   718     }

   719     end = System.currentTimeMillis();

   720     System.out.println("test_2vi_aln: " + (end - start));

   721 

   722     start = System.currentTimeMillis();

   723     for (int i=0; i<ITERS; i++) {

   724       test_cp_unalndst(a1, a2);

   725     }

   726     end = System.currentTimeMillis();

   727     System.out.println("test_cp_unalndst: " + (end - start));

   728     start = System.currentTimeMillis();

   729     for (int i=0; i<ITERS; i++) {

   730       test_cp_unalnsrc(a1, a2);

   731     }

   732     end = System.currentTimeMillis();

   733     System.out.println("test_cp_unalnsrc: " + (end - start));

   734     start = System.currentTimeMillis();

   735     for (int i=0; i<ITERS; i++) {

   736       test_2ci_unaln(a1, a2);

   737     }

   738     end = System.currentTimeMillis();

   739     System.out.println("test_2ci_unaln: " + (end - start));

   740     start = System.currentTimeMillis();

   741     for (int i=0; i<ITERS; i++) {

   742       test_2vi_unaln(a1, a2, 123, 103);

   743     }

   744     end = System.currentTimeMillis();

   745     System.out.println("test_2vi_unaln: " + (end - start));

   746 

   747     return errn;

   748   }

   749 

   750   static void test_ci(AtomicIntegerArray a) {

   751     for (int i = 0; i < ARRLEN; i+=1) {

   752       a.lazySet(i, -123);

   753     }

   754   }

   755   static void test_vi(AtomicIntegerArray a, int b, int old) {

   756     for (int i = 0; i < ARRLEN; i+=1) {

   757       a.lazySet(i, b);

   758     }

   759   }

   760   static void test_cp(AtomicIntegerArray a, AtomicIntegerArray b) {

   761     for (int i = 0; i < ARRLEN; i+=1) {

   762       a.lazySet(i, b.get(i));

   763     }

   764   }

   765   static void test_2ci(AtomicIntegerArray a, AtomicIntegerArray b) {

   766     for (int i = 0; i < ARRLEN; i+=1) {

   767       a.lazySet(i, -123);

   768       b.lazySet(i, -103);

   769     }

   770   }

   771   static void test_2vi(AtomicIntegerArray a, AtomicIntegerArray b, int c, int d) {

   772     for (int i = 0; i < ARRLEN; i+=1) {

   773       a.lazySet(i, c);

   774       b.lazySet(i, d);

   775     }

   776   }

   777   static void test_ci_neg(AtomicIntegerArray a, int old) {

   778     for (int i = ARRLEN-1; i >= 0; i-=1) {

   779       a.lazySet(i,-123);

   780     }

   781   }

   782   static void test_vi_neg(AtomicIntegerArray a, int b, int old) {

   783     for (int i = ARRLEN-1; i >= 0; i-=1) {

   784       a.lazySet(i, b);

   785     }

   786   }

   787   static void test_cp_neg(AtomicIntegerArray a, AtomicIntegerArray b) {

   788     for (int i = ARRLEN-1; i >= 0; i-=1) {

   789       a.lazySet(i, b.get(i));

   790     }

   791   }

   792   static void test_2ci_neg(AtomicIntegerArray a, AtomicIntegerArray b) {

   793     for (int i = ARRLEN-1; i >= 0; i-=1) {

   794       a.lazySet(i, -123);

   795       b.lazySet(i, -103);

   796     }

   797   }

   798   static void test_2vi_neg(AtomicIntegerArray a, AtomicIntegerArray b, int c, int d) {

   799     for (int i = ARRLEN-1; i >= 0; i-=1) {

   800       a.lazySet(i, c);

   801       b.lazySet(i, d);

   802     }

   803   }

   804   static void test_ci_oppos(AtomicIntegerArray a, int old) {

   805     int limit = ARRLEN-1;

   806     for (int i = 0; i < ARRLEN; i+=1) {

   807       a.lazySet((limit-i), -123);

   808     }

   809   }

   810   static void test_vi_oppos(AtomicIntegerArray a, int b, int old) {

   811     int limit = ARRLEN-1;

   812     for (int i = limit; i >= 0; i-=1) {

   813       a.lazySet((limit-i), b);

   814     }

   815   }

   816   static void test_cp_oppos(AtomicIntegerArray a, AtomicIntegerArray b) {

   817     int limit = ARRLEN-1;

   818     for (int i = 0; i < ARRLEN; i+=1) {

   819       a.lazySet(i, b.get(limit-i));

   820     }

   821   }

   822   static void test_2ci_oppos(AtomicIntegerArray a, AtomicIntegerArray b) {

   823     int limit = ARRLEN-1;

   824     for (int i = 0; i < ARRLEN; i+=1) {

   825       a.lazySet((limit-i), -123);

   826       b.lazySet(i, -103);

   827     }

   828   }

   829   static void test_2vi_oppos(AtomicIntegerArray a, AtomicIntegerArray b, int c, int d) {

   830     int limit = ARRLEN-1;

   831     for (int i = limit; i >= 0; i-=1) {

   832       a.lazySet(i, c);

   833       b.lazySet((limit-i), d);

   834     }

   835   }

   836   static void test_ci_off(AtomicIntegerArray a, int old) {

   837     for (int i = 0; i < ARRLEN-OFFSET; i+=1) {

   838       a.lazySet((i+OFFSET), -123);

   839     }

   840   }

   841   static void test_vi_off(AtomicIntegerArray a, int b, int old) {

   842     for (int i = 0; i < ARRLEN-OFFSET; i+=1) {

   843       a.lazySet((i+OFFSET), b);

   844     }

   845   }

   846   static void test_cp_off(AtomicIntegerArray a, AtomicIntegerArray b) {

   847     for (int i = 0; i < ARRLEN-OFFSET; i+=1) {

   848       a.lazySet((i+OFFSET), b.get(i+OFFSET));

   849     }

   850   }

   851   static void test_2ci_off(AtomicIntegerArray a, AtomicIntegerArray b) {

   852     for (int i = 0; i < ARRLEN-OFFSET; i+=1) {

   853       a.lazySet((i+OFFSET), -123);

   854       b.lazySet((i+OFFSET), -103);

   855     }

   856   }

   857   static void test_2vi_off(AtomicIntegerArray a, AtomicIntegerArray b, int c, int d) {

   858     for (int i = 0; i < ARRLEN-OFFSET; i+=1) {

   859       a.lazySet((i+OFFSET), c);

   860       b.lazySet((i+OFFSET), d);

   861     }

   862   }

   863   static void test_ci_inv(AtomicIntegerArray a, int k, int old) {

   864     for (int i = 0; i < ARRLEN-k; i+=1) {

   865       a.lazySet((i+k),-123);

   866     }

   867   }

   868   static void test_vi_inv(AtomicIntegerArray a, int b, int k, int old) {

   869     for (int i = 0; i < ARRLEN-k; i+=1) {

   870       a.lazySet((i+k), b);

   871     }

   872   }

   873   static void test_cp_inv(AtomicIntegerArray a, AtomicIntegerArray b, int k) {

   874     for (int i = 0; i < ARRLEN-k; i+=1) {

   875       a.lazySet((i+k), b.get(i+k));

   876     }

   877   }

   878   static void test_2ci_inv(AtomicIntegerArray a, AtomicIntegerArray b, int k) {

   879     for (int i = 0; i < ARRLEN-k; i+=1) {

   880       a.lazySet((i+k), -123);

   881       b.lazySet((i+k), -103);

   882     }

   883   }

   884   static void test_2vi_inv(AtomicIntegerArray a, AtomicIntegerArray b, int c, int d, int k) {

   885     for (int i = 0; i < ARRLEN-k; i+=1) {

   886       a.lazySet((i+k), c);

   887       b.lazySet((i+k), d);

   888     }

   889   }

   890   static void test_ci_scl(AtomicIntegerArray a, int old) {

   891     for (int i = 0; i*SCALE < ARRLEN; i+=1) {

   892       a.lazySet((i*SCALE), -123);

   893     }

   894   }

   895   static void test_vi_scl(AtomicIntegerArray a, int b, int old) {

   896     for (int i = 0; i*SCALE < ARRLEN; i+=1) {

   897       a.lazySet((i*SCALE), b);

   898     }

   899   }

   900   static void test_cp_scl(AtomicIntegerArray a, AtomicIntegerArray b) {

   901     for (int i = 0; i*SCALE < ARRLEN; i+=1) {

   902       a.lazySet((i*SCALE), b.get(i*SCALE));

   903     }

   904   }

   905   static void test_2ci_scl(AtomicIntegerArray a, AtomicIntegerArray b) {

   906     for (int i = 0; i*SCALE < ARRLEN; i+=1) {

   907       a.lazySet((i*SCALE), -123);

   908       b.lazySet((i*SCALE), -103);

   909     }

   910   }

   911   static void test_2vi_scl(AtomicIntegerArray a, AtomicIntegerArray b, int c, int d) {

   912     for (int i = 0; i*SCALE < ARRLEN; i+=1) {

   913       a.lazySet((i*SCALE), c);

   914       b.lazySet((i*SCALE), d);

   915     }

   916   }

   917   static void test_cp_alndst(AtomicIntegerArray a, AtomicIntegerArray b) {

   918     for (int i = 0; i < ARRLEN-ALIGN_OFF; i+=1) {

   919       a.lazySet((i+ALIGN_OFF), b.get(i));

   920     }

   921   }

   922   static void test_cp_alnsrc(AtomicIntegerArray a, AtomicIntegerArray b) {

   923     for (int i = 0; i < ARRLEN-ALIGN_OFF; i+=1) {

   924       a.lazySet(i, b.get(i+ALIGN_OFF));

   925     }

   926   }

   927   static void test_2ci_aln(AtomicIntegerArray a, AtomicIntegerArray b) {

   928     for (int i = 0; i < ARRLEN-ALIGN_OFF; i+=1) {

   929       a.lazySet((i+ALIGN_OFF), -123);

   930       b.lazySet(i, -103);

   931     }

   932   }

   933   static void test_2vi_aln(AtomicIntegerArray a, AtomicIntegerArray b, int c, int d) {

   934     for (int i = 0; i < ARRLEN-ALIGN_OFF; i+=1) {

   935       a.lazySet(i, c);

   936       b.lazySet((i+ALIGN_OFF), d);

   937     }

   938   }

   939   static void test_cp_unalndst(AtomicIntegerArray a, AtomicIntegerArray b) {

   940     for (int i = 0; i < ARRLEN-UNALIGN_OFF; i+=1) {

   941       a.lazySet((i+UNALIGN_OFF), b.get(i));

   942     }

   943   }

   944   static void test_cp_unalnsrc(AtomicIntegerArray a, AtomicIntegerArray b) {

   945     for (int i = 0; i < ARRLEN-UNALIGN_OFF; i+=1) {

   946       a.lazySet(i, b.get(i+UNALIGN_OFF));

   947     }

   948   }

   949   static void test_2ci_unaln(AtomicIntegerArray a, AtomicIntegerArray b) {

   950     for (int i = 0; i < ARRLEN-UNALIGN_OFF; i+=1) {

   951       a.lazySet((i+UNALIGN_OFF), -123);

   952       b.lazySet(i, -103);

   953     }

   954   }

   955   static void test_2vi_unaln(AtomicIntegerArray a, AtomicIntegerArray b, int c, int d) {

   956     for (int i = 0; i < ARRLEN-UNALIGN_OFF; i+=1) {

   957       a.lazySet(i, c);

   958       b.lazySet((i+UNALIGN_OFF), d);

   959     }

   960   }

   961 

   962   static int verify(String text, int i, int elem, int val) {

   963     if (elem != val) {

   964       System.err.println(text + "[" + i + "] = " + elem + " != " + val);

   965       return 1;

   966     }

   967     return 0;

   968   }

   969 }