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 7119644

    28  * @summary Increase superword's vector size up to 256 bits

    29  *

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

    31  *    -XX:-TieredCompilation -XX:-OptimizeFill

    32  *    compiler.codegen.TestCharVect

    33  */

    34 

    35 package compiler.codegen;

    36 

    37 public class TestCharVect {

    38   private static final int ARRLEN = 997;

    39   private static final int ITERS  = 11000;

    40   private static final int OFFSET = 3;

    41   private static final int SCALE = 2;

    42   private static final int ALIGN_OFF = 8;

    43   private static final int UNALIGN_OFF = 5;

    44 

    45   public static void main(String args[]) {

    46     System.out.println("Testing Char vectors");

    47     int errn = test();

    48     if (errn > 0) {

    49       System.err.println("FAILED: " + errn + " errors");

    50       System.exit(97);

    51     }

    52     System.out.println("PASSED");

    53   }

    54 

    55   static int test() {

    56     char[] a1 = new char[ARRLEN];

    57     char[] a2 = new char[ARRLEN];

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

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

    60       test_ci(a1);

    61       test_vi(a2, (char)123);

    62       test_cp(a1, a2);

    63       test_2ci(a1, a2);

    64       test_2vi(a1, a2, (char)123, (char)103);

    65       test_ci_neg(a1);

    66       test_vi_neg(a2, (char)123);

    67       test_cp_neg(a1, a2);

    68       test_2ci_neg(a1, a2);

    69       test_2vi_neg(a1, a2, (char)123, (char)103);

    70       test_ci_oppos(a1);

    71       test_vi_oppos(a2, (char)123);

    72       test_cp_oppos(a1, a2);

    73       test_2ci_oppos(a1, a2);

    74       test_2vi_oppos(a1, a2, (char)123, (char)103);

    75       test_ci_off(a1);

    76       test_vi_off(a2, (char)123);

    77       test_cp_off(a1, a2);

    78       test_2ci_off(a1, a2);

    79       test_2vi_off(a1, a2, (char)123, (char)103);

    80       test_ci_inv(a1, OFFSET);

    81       test_vi_inv(a2, (char)123, OFFSET);

    82       test_cp_inv(a1, a2, OFFSET);

    83       test_2ci_inv(a1, a2, OFFSET);

    84       test_2vi_inv(a1, a2, (char)123, (char)103, OFFSET);

    85       test_ci_scl(a1);

    86       test_vi_scl(a2, (char)123);

    87       test_cp_scl(a1, a2);

    88       test_2ci_scl(a1, a2);

    89       test_2vi_scl(a1, a2, (char)123, (char)103);

    90       test_cp_alndst(a1, a2);

    91       test_cp_alnsrc(a1, a2);

    92       test_2ci_aln(a1, a2);

    93       test_2vi_aln(a1, a2, (char)123, (char)103);

    94       test_cp_unalndst(a1, a2);

    95       test_cp_unalnsrc(a1, a2);

    96       test_2ci_unaln(a1, a2);

    97       test_2vi_unaln(a1, a2, (char)123, (char)103);

    98     }

    99     // Initialize

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

   101       a1[i] = (char)-1;

   102       a2[i] = (char)-1;

   103     }

   104     // Test and verify results

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

   106     int errn = 0;

   107     {

   108       test_ci(a1);

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

   110         errn += verify("test_ci: a1", i, a1[i], (char)-123);

   111       }

   112       test_vi(a2, (char)123);

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

   114         errn += verify("test_vi: a2", i, a2[i], (char)123);

   115       }

   116       test_cp(a1, a2);

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

   118         errn += verify("test_cp: a1", i, a1[i], (char)123);

   119       }

   120       test_2ci(a1, a2);

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

   122         errn += verify("test_2ci: a1", i, a1[i], (char)-123);

   123         errn += verify("test_2ci: a2", i, a2[i], (char)-103);

   124       }

   125       test_2vi(a1, a2, (char)123, (char)103);

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

   127         errn += verify("test_2vi: a1", i, a1[i], (char)123);

   128         errn += verify("test_2vi: a2", i, a2[i], (char)103);

   129       }

   130       // Reset for negative stride

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

   132         a1[i] = (char)-1;

   133         a2[i] = (char)-1;

   134       }

   135       test_ci_neg(a1);

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

   137         errn += verify("test_ci_neg: a1", i, a1[i], (char)-123);

   138       }

   139       test_vi_neg(a2, (char)123);

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

   141         errn += verify("test_vi_neg: a2", i, a2[i], (char)123);

   142       }

   143       test_cp_neg(a1, a2);

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

   145         errn += verify("test_cp_neg: a1", i, a1[i], (char)123);

   146       }

   147       test_2ci_neg(a1, a2);

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

   149         errn += verify("test_2ci_neg: a1", i, a1[i], (char)-123);

   150         errn += verify("test_2ci_neg: a2", i, a2[i], (char)-103);

   151       }

   152       test_2vi_neg(a1, a2, (char)123, (char)103);

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

   154         errn += verify("test_2vi_neg: a1", i, a1[i], (char)123);

   155         errn += verify("test_2vi_neg: a2", i, a2[i], (char)103);

   156       }

   157       // Reset for opposite stride

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

   159         a1[i] = (char)-1;

   160         a2[i] = (char)-1;

   161       }

   162       test_ci_oppos(a1);

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

   164         errn += verify("test_ci_oppos: a1", i, a1[i], (char)-123);

   165       }

   166       test_vi_oppos(a2, (char)123);

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

   168         errn += verify("test_vi_oppos: a2", i, a2[i], (char)123);

   169       }

   170       test_cp_oppos(a1, a2);

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

   172         errn += verify("test_cp_oppos: a1", i, a1[i], (char)123);

   173       }

   174       test_2ci_oppos(a1, a2);

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

   176         errn += verify("test_2ci_oppos: a1", i, a1[i], (char)-123);

   177         errn += verify("test_2ci_oppos: a2", i, a2[i], (char)-103);

   178       }

   179       test_2vi_oppos(a1, a2, (char)123, (char)103);

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

   181         errn += verify("test_2vi_oppos: a1", i, a1[i], (char)123);

   182         errn += verify("test_2vi_oppos: a2", i, a2[i], (char)103);

   183       }

   184       // Reset for indexing with offset

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

   186         a1[i] = (char)-1;

   187         a2[i] = (char)-1;

   188       }

   189       test_ci_off(a1);

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

   191         errn += verify("test_ci_off: a1", i, a1[i], (char)-123);

   192       }

   193       test_vi_off(a2, (char)123);

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

   195         errn += verify("test_vi_off: a2", i, a2[i], (char)123);

   196       }

   197       test_cp_off(a1, a2);

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

   199         errn += verify("test_cp_off: a1", i, a1[i], (char)123);

   200       }

   201       test_2ci_off(a1, a2);

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

   203         errn += verify("test_2ci_off: a1", i, a1[i], (char)-123);

   204         errn += verify("test_2ci_off: a2", i, a2[i], (char)-103);

   205       }

   206       test_2vi_off(a1, a2, (char)123, (char)103);

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

   208         errn += verify("test_2vi_off: a1", i, a1[i], (char)123);

   209         errn += verify("test_2vi_off: a2", i, a2[i], (char)103);

   210       }

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

   212         errn += verify("test_2vi_off: a1", i, a1[i], (char)-1);

   213         errn += verify("test_2vi_off: a2", i, a2[i], (char)-1);

   214       }

   215       // Reset for indexing with invariant offset

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

   217         a1[i] = (char)-1;

   218         a2[i] = (char)-1;

   219       }

   220       test_ci_inv(a1, OFFSET);

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

   222         errn += verify("test_ci_inv: a1", i, a1[i], (char)-123);

   223       }

   224       test_vi_inv(a2, (char)123, OFFSET);

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

   226         errn += verify("test_vi_inv: a2", i, a2[i], (char)123);

   227       }

   228       test_cp_inv(a1, a2, OFFSET);

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

   230         errn += verify("test_cp_inv: a1", i, a1[i], (char)123);

   231       }

   232       test_2ci_inv(a1, a2, OFFSET);

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

   234         errn += verify("test_2ci_inv: a1", i, a1[i], (char)-123);

   235         errn += verify("test_2ci_inv: a2", i, a2[i], (char)-103);

   236       }

   237       test_2vi_inv(a1, a2, (char)123, (char)103, OFFSET);

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

   239         errn += verify("test_2vi_inv: a1", i, a1[i], (char)123);

   240         errn += verify("test_2vi_inv: a2", i, a2[i], (char)103);

   241       }

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

   243         errn += verify("test_2vi_inv: a1", i, a1[i], (char)-1);

   244         errn += verify("test_2vi_inv: a2", i, a2[i], (char)-1);

   245       }

   246       // Reset for indexing with scale

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

   248         a1[i] = (char)-1;

   249         a2[i] = (char)-1;

   250       }

   251       test_ci_scl(a1);

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

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

   254         errn += verify("test_ci_scl: a1", i, a1[i], (char)val);

   255       }

   256       test_vi_scl(a2, (char)123);

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

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

   259         errn += verify("test_vi_scl: a2", i, a2[i], (char)val);

   260       }

   261       test_cp_scl(a1, a2);

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

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

   264         errn += verify("test_cp_scl: a1", i, a1[i], (char)val);

   265       }

   266       test_2ci_scl(a1, a2);

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

   268         if (i%SCALE != 0) {

   269           errn += verify("test_2ci_scl: a1", i, a1[i], (char)-1);

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

   271           errn += verify("test_2ci_scl: a1", i*SCALE, a1[i*SCALE], (char)-123);

   272         }

   273         if (i%SCALE != 0) {

   274           errn += verify("test_2ci_scl: a2", i, a2[i], (char)-1);

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

   276           errn += verify("test_2ci_scl: a2", i*SCALE, a2[i*SCALE], (char)-103);

   277         }

   278       }

   279       test_2vi_scl(a1, a2, (char)123, (char)103);

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

   281         if (i%SCALE != 0) {

   282           errn += verify("test_2vi_scl: a1", i, a1[i], (char)-1);

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

   284           errn += verify("test_2vi_scl: a1", i*SCALE, a1[i*SCALE], (char)123);

   285         }

   286         if (i%SCALE != 0) {

   287           errn += verify("test_2vi_scl: a2", i, a2[i], (char)-1);

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

   289           errn += verify("test_2vi_scl: a2", i*SCALE, a2[i*SCALE], (char)103);

   290         }

   291       }

   292       // Reset for 2 arrays with relative aligned offset

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

   294         a1[i] = (char)-1;

   295         a2[i] = (char)-1;

   296       }

   297       test_vi(a2, (char)123);

   298       test_cp_alndst(a1, a2);

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

   300         errn += verify("test_cp_alndst: a1", i, a1[i], (char)-1);

   301       }

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

   303         errn += verify("test_cp_alndst: a1", i, a1[i], (char)123);

   304       }

   305       test_vi(a2, (char)-123);

   306       test_cp_alnsrc(a1, a2);

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

   308         errn += verify("test_cp_alnsrc: a1", i, a1[i], (char)-123);

   309       }

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

   311         errn += verify("test_cp_alnsrc: a1", i, a1[i], (char)123);

   312       }

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

   314         a1[i] = (char)-1;

   315         a2[i] = (char)-1;

   316       }

   317       test_2ci_aln(a1, a2);

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

   319         errn += verify("test_2ci_aln: a1", i, a1[i], (char)-1);

   320       }

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

   322         errn += verify("test_2ci_aln: a1", i, a1[i], (char)-123);

   323       }

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

   325         errn += verify("test_2ci_aln: a2", i, a2[i], (char)-103);

   326       }

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

   328         errn += verify("test_2ci_aln: a2", i, a2[i], (char)-1);

   329       }

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

   331         a1[i] = (char)-1;

   332         a2[i] = (char)-1;

   333       }

   334       test_2vi_aln(a1, a2, (char)123, (char)103);

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

   336         errn += verify("test_2vi_aln: a1", i, a1[i], (char)123);

   337       }

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

   339         errn += verify("test_2vi_aln: a1", i, a1[i], (char)-1);

   340       }

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

   342         errn += verify("test_2vi_aln: a2", i, a2[i], (char)-1);

   343       }

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

   345         errn += verify("test_2vi_aln: a2", i, a2[i], (char)103);

   346       }

   347 

   348       // Reset for 2 arrays with relative unaligned offset

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

   350         a1[i] = (char)-1;

   351         a2[i] = (char)-1;

   352       }

   353       test_vi(a2, (char)123);

   354       test_cp_unalndst(a1, a2);

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

   356         errn += verify("test_cp_unalndst: a1", i, a1[i], (char)-1);

   357       }

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

   359         errn += verify("test_cp_unalndst: a1", i, a1[i], (char)123);

   360       }

   361       test_vi(a2, (char)-123);

   362       test_cp_unalnsrc(a1, a2);

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

   364         errn += verify("test_cp_unalnsrc: a1", i, a1[i], (char)-123);

   365       }

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

   367         errn += verify("test_cp_unalnsrc: a1", i, a1[i], (char)123);

   368       }

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

   370         a1[i] = (char)-1;

   371         a2[i] = (char)-1;

   372       }

   373       test_2ci_unaln(a1, a2);

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

   375         errn += verify("test_2ci_unaln: a1", i, a1[i], (char)-1);

   376       }

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

   378         errn += verify("test_2ci_unaln: a1", i, a1[i], (char)-123);

   379       }

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

   381         errn += verify("test_2ci_unaln: a2", i, a2[i], (char)-103);

   382       }

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

   384         errn += verify("test_2ci_unaln: a2", i, a2[i], (char)-1);

   385       }

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

   387         a1[i] = (char)-1;

   388         a2[i] = (char)-1;

   389       }

   390       test_2vi_unaln(a1, a2, (char)123, (char)103);

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

   392         errn += verify("test_2vi_unaln: a1", i, a1[i], (char)123);

   393       }

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

   395         errn += verify("test_2vi_unaln: a1", i, a1[i], (char)-1);

   396       }

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

   398         errn += verify("test_2vi_unaln: a2", i, a2[i], (char)-1);

   399       }

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

   401         errn += verify("test_2vi_unaln: a2", i, a2[i], (char)103);

   402       }

   403 

   404       // Reset for aligned overlap initialization

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

   406         a1[i] = (char)i;

   407       }

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

   409         a1[i] = (char)-1;

   410       }

   411       test_cp_alndst(a1, a1);

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

   413         int v = i%ALIGN_OFF;

   414         errn += verify("test_cp_alndst_overlap: a1", i, a1[i], (char)v);

   415       }

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

   417         a1[i+ALIGN_OFF] = (char)-1;

   418       }

   419       test_cp_alnsrc(a1, a1);

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

   421         errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], (char)-1);

   422       }

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

   424         int v = i%ALIGN_OFF;

   425         errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], (char)v);

   426       }

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

   428         a1[i] = (char)-1;

   429       }

   430       test_2ci_aln(a1, a1);

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

   432         errn += verify("test_2ci_aln_overlap: a1", i, a1[i], (char)-103);

   433       }

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

   435         errn += verify("test_2ci_aln_overlap: a1", i, a1[i], (char)-123);

   436       }

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

   438         a1[i] = (char)-1;

   439       }

   440       test_2vi_aln(a1, a1, (char)123, (char)103);

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

   442         errn += verify("test_2vi_aln_overlap: a1", i, a1[i], (char)123);

   443       }

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

   445         errn += verify("test_2vi_aln_overlap: a1", i, a1[i], (char)103);

   446       }

   447 

   448       // Reset for unaligned overlap initialization

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

   450         a1[i] = (char)i;

   451       }

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

   453         a1[i] = (char)-1;

   454       }

   455       test_cp_unalndst(a1, a1);

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

   457         int v = i%UNALIGN_OFF;

   458         errn += verify("test_cp_unalndst_overlap: a1", i, a1[i], (char)v);

   459       }

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

   461         a1[i+UNALIGN_OFF] = (char)-1;

   462       }

   463       test_cp_unalnsrc(a1, a1);

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

   465         errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], (char)-1);

   466       }

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

   468         int v = i%UNALIGN_OFF;

   469         errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], (char)v);

   470       }

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

   472         a1[i] = (char)-1;

   473       }

   474       test_2ci_unaln(a1, a1);

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

   476         errn += verify("test_2ci_unaln_overlap: a1", i, a1[i], (char)-103);

   477       }

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

   479         errn += verify("test_2ci_unaln_overlap: a1", i, a1[i], (char)-123);

   480       }

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

   482         a1[i] = (char)-1;

   483       }

   484       test_2vi_unaln(a1, a1, (char)123, (char)103);

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

   486         errn += verify("test_2vi_unaln_overlap: a1", i, a1[i], (char)123);

   487       }

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

   489         errn += verify("test_2vi_unaln_overlap: a1", i, a1[i], (char)103);

   490       }

   491 

   492     }

   493 

   494     if (errn > 0)

   495       return errn;

   496 

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

   498     long start, end;

   499     start = System.currentTimeMillis();

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

   501       test_ci(a1);

   502     }

   503     end = System.currentTimeMillis();

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

   505     start = System.currentTimeMillis();

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

   507       test_vi(a2, (char)123);

   508     }

   509     end = System.currentTimeMillis();

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

   511     start = System.currentTimeMillis();

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

   513       test_cp(a1, a2);

   514     }

   515     end = System.currentTimeMillis();

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

   517     start = System.currentTimeMillis();

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

   519       test_2ci(a1, a2);

   520     }

   521     end = System.currentTimeMillis();

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

   523     start = System.currentTimeMillis();

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

   525       test_2vi(a1, a2, (char)123, (char)103);

   526     }

   527     end = System.currentTimeMillis();

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

   529 

   530     start = System.currentTimeMillis();

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

   532       test_ci_neg(a1);

   533     }

   534     end = System.currentTimeMillis();

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

   536     start = System.currentTimeMillis();

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

   538       test_vi_neg(a2, (char)123);

   539     }

   540     end = System.currentTimeMillis();

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

   542     start = System.currentTimeMillis();

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

   544       test_cp_neg(a1, a2);

   545     }

   546     end = System.currentTimeMillis();

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

   548     start = System.currentTimeMillis();

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

   550       test_2ci_neg(a1, a2);

   551     }

   552     end = System.currentTimeMillis();

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

   554     start = System.currentTimeMillis();

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

   556       test_2vi_neg(a1, a2, (char)123, (char)103);

   557     }

   558     end = System.currentTimeMillis();

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

   560 

   561     start = System.currentTimeMillis();

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

   563       test_ci_oppos(a1);

   564     }

   565     end = System.currentTimeMillis();

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

   567     start = System.currentTimeMillis();

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

   569       test_vi_oppos(a2, (char)123);

   570     }

   571     end = System.currentTimeMillis();

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

   573     start = System.currentTimeMillis();

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

   575       test_cp_oppos(a1, a2);

   576     }

   577     end = System.currentTimeMillis();

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

   579     start = System.currentTimeMillis();

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

   581       test_2ci_oppos(a1, a2);

   582     }

   583     end = System.currentTimeMillis();

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

   585     start = System.currentTimeMillis();

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

   587       test_2vi_oppos(a1, a2, (char)123, (char)103);

   588     }

   589     end = System.currentTimeMillis();

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

   591 

   592     start = System.currentTimeMillis();

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

   594       test_ci_off(a1);

   595     }

   596     end = System.currentTimeMillis();

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

   598     start = System.currentTimeMillis();

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

   600       test_vi_off(a2, (char)123);

   601     }

   602     end = System.currentTimeMillis();

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

   604     start = System.currentTimeMillis();

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

   606       test_cp_off(a1, a2);

   607     }

   608     end = System.currentTimeMillis();

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

   610     start = System.currentTimeMillis();

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

   612       test_2ci_off(a1, a2);

   613     }

   614     end = System.currentTimeMillis();

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

   616     start = System.currentTimeMillis();

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

   618       test_2vi_off(a1, a2, (char)123, (char)103);

   619     }

   620     end = System.currentTimeMillis();

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

   622 

   623     start = System.currentTimeMillis();

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

   625       test_ci_inv(a1, OFFSET);

   626     }

   627     end = System.currentTimeMillis();

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

   629     start = System.currentTimeMillis();

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

   631       test_vi_inv(a2, (char)123, OFFSET);

   632     }

   633     end = System.currentTimeMillis();

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

   635     start = System.currentTimeMillis();

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

   637       test_cp_inv(a1, a2, OFFSET);

   638     }

   639     end = System.currentTimeMillis();

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

   641     start = System.currentTimeMillis();

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

   643       test_2ci_inv(a1, a2, OFFSET);

   644     }

   645     end = System.currentTimeMillis();

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

   647     start = System.currentTimeMillis();

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

   649       test_2vi_inv(a1, a2, (char)123, (char)103, OFFSET);

   650     }

   651     end = System.currentTimeMillis();

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

   653 

   654     start = System.currentTimeMillis();

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

   656       test_ci_scl(a1);

   657     }

   658     end = System.currentTimeMillis();

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

   660     start = System.currentTimeMillis();

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

   662       test_vi_scl(a2, (char)123);

   663     }

   664     end = System.currentTimeMillis();

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

   666     start = System.currentTimeMillis();

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

   668       test_cp_scl(a1, a2);

   669     }

   670     end = System.currentTimeMillis();

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

   672     start = System.currentTimeMillis();

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

   674       test_2ci_scl(a1, a2);

   675     }

   676     end = System.currentTimeMillis();

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

   678     start = System.currentTimeMillis();

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

   680       test_2vi_scl(a1, a2, (char)123, (char)103);

   681     }

   682     end = System.currentTimeMillis();

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

   684 

   685     start = System.currentTimeMillis();

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

   687       test_cp_alndst(a1, a2);

   688     }

   689     end = System.currentTimeMillis();

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

   691     start = System.currentTimeMillis();

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

   693       test_cp_alnsrc(a1, a2);

   694     }

   695     end = System.currentTimeMillis();

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

   697     start = System.currentTimeMillis();

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

   699       test_2ci_aln(a1, a2);

   700     }

   701     end = System.currentTimeMillis();

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

   703     start = System.currentTimeMillis();

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

   705       test_2vi_aln(a1, a2, (char)123, (char)103);

   706     }

   707     end = System.currentTimeMillis();

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

   709 

   710     start = System.currentTimeMillis();

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

   712       test_cp_unalndst(a1, a2);

   713     }

   714     end = System.currentTimeMillis();

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

   716     start = System.currentTimeMillis();

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

   718       test_cp_unalnsrc(a1, a2);

   719     }

   720     end = System.currentTimeMillis();

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

   722     start = System.currentTimeMillis();

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

   724       test_2ci_unaln(a1, a2);

   725     }

   726     end = System.currentTimeMillis();

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

   728     start = System.currentTimeMillis();

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

   730       test_2vi_unaln(a1, a2, (char)123, (char)103);

   731     }

   732     end = System.currentTimeMillis();

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

   734 

   735     return errn;

   736   }

   737 

   738   static void test_ci(char[] a) {

   739     for (int i = 0; i < a.length; i+=1) {

   740       a[i] = (char)-123;

   741     }

   742   }

   743   static void test_vi(char[] a, char b) {

   744     for (int i = 0; i < a.length; i+=1) {

   745       a[i] = b;

   746     }

   747   }

   748   static void test_cp(char[] a, char[] b) {

   749     for (int i = 0; i < a.length; i+=1) {

   750       a[i] = b[i];

   751     }

   752   }

   753   static void test_2ci(char[] a, char[] b) {

   754     for (int i = 0; i < a.length; i+=1) {

   755       a[i] = (char)-123;

   756       b[i] = (char)-103;

   757     }

   758   }

   759   static void test_2vi(char[] a, char[] b, char c, char d) {

   760     for (int i = 0; i < a.length; i+=1) {

   761       a[i] = c;

   762       b[i] = d;

   763     }

   764   }

   765   static void test_ci_neg(char[] a) {

   766     for (int i = a.length-1; i >= 0; i-=1) {

   767       a[i] = (char)-123;

   768     }

   769   }

   770   static void test_vi_neg(char[] a, char b) {

   771     for (int i = a.length-1; i >= 0; i-=1) {

   772       a[i] = b;

   773     }

   774   }

   775   static void test_cp_neg(char[] a, char[] b) {

   776     for (int i = a.length-1; i >= 0; i-=1) {

   777       a[i] = b[i];

   778     }

   779   }

   780   static void test_2ci_neg(char[] a, char[] b) {

   781     for (int i = a.length-1; i >= 0; i-=1) {

   782       a[i] = (char)-123;

   783       b[i] = (char)-103;

   784     }

   785   }

   786   static void test_2vi_neg(char[] a, char[] b, char c, char d) {

   787     for (int i = a.length-1; i >= 0; i-=1) {

   788       a[i] = c;

   789       b[i] = d;

   790     }

   791   }

   792   static void test_ci_oppos(char[] a) {

   793     int limit = a.length-1;

   794     for (int i = 0; i < a.length; i+=1) {

   795       a[limit-i] = (char)-123;

   796     }

   797   }

   798   static void test_vi_oppos(char[] a, char b) {

   799     int limit = a.length-1;

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

   801       a[limit-i] = b;

   802     }

   803   }

   804   static void test_cp_oppos(char[] a, char[] b) {

   805     int limit = a.length-1;

   806     for (int i = 0; i < a.length; i+=1) {

   807       a[i] = b[limit-i];

   808     }

   809   }

   810   static void test_2ci_oppos(char[] a, char[] b) {

   811     int limit = a.length-1;

   812     for (int i = 0; i < a.length; i+=1) {

   813       a[limit-i] = (char)-123;

   814       b[i] = (char)-103;

   815     }

   816   }

   817   static void test_2vi_oppos(char[] a, char[] b, char c, char d) {

   818     int limit = a.length-1;

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

   820       a[i] = c;

   821       b[limit-i] = d;

   822     }

   823   }

   824   static void test_ci_off(char[] a) {

   825     for (int i = 0; i < a.length-OFFSET; i+=1) {

   826       a[i+OFFSET] = (char)-123;

   827     }

   828   }

   829   static void test_vi_off(char[] a, char b) {

   830     for (int i = 0; i < a.length-OFFSET; i+=1) {

   831       a[i+OFFSET] = b;

   832     }

   833   }

   834   static void test_cp_off(char[] a, char[] b) {

   835     for (int i = 0; i < a.length-OFFSET; i+=1) {

   836       a[i+OFFSET] = b[i+OFFSET];

   837     }

   838   }

   839   static void test_2ci_off(char[] a, char[] b) {

   840     for (int i = 0; i < a.length-OFFSET; i+=1) {

   841       a[i+OFFSET] = (char)-123;

   842       b[i+OFFSET] = (char)-103;

   843     }

   844   }

   845   static void test_2vi_off(char[] a, char[] b, char c, char d) {

   846     for (int i = 0; i < a.length-OFFSET; i+=1) {

   847       a[i+OFFSET] = c;

   848       b[i+OFFSET] = d;

   849     }

   850   }

   851   static void test_ci_inv(char[] a, int k) {

   852     for (int i = 0; i < a.length-k; i+=1) {

   853       a[i+k] = (char)-123;

   854     }

   855   }

   856   static void test_vi_inv(char[] a, char b, int k) {

   857     for (int i = 0; i < a.length-k; i+=1) {

   858       a[i+k] = b;

   859     }

   860   }

   861   static void test_cp_inv(char[] a, char[] b, int k) {

   862     for (int i = 0; i < a.length-k; i+=1) {

   863       a[i+k] = b[i+k];

   864     }

   865   }

   866   static void test_2ci_inv(char[] a, char[] b, int k) {

   867     for (int i = 0; i < a.length-k; i+=1) {

   868       a[i+k] = (char)-123;

   869       b[i+k] = (char)-103;

   870     }

   871   }

   872   static void test_2vi_inv(char[] a, char[] b, char c, char d, int k) {

   873     for (int i = 0; i < a.length-k; i+=1) {

   874       a[i+k] = c;

   875       b[i+k] = d;

   876     }

   877   }

   878   static void test_ci_scl(char[] a) {

   879     for (int i = 0; i*SCALE < a.length; i+=1) {

   880       a[i*SCALE] = (char)-123;

   881     }

   882   }

   883   static void test_vi_scl(char[] a, char b) {

   884     for (int i = 0; i*SCALE < a.length; i+=1) {

   885       a[i*SCALE] = b;

   886     }

   887   }

   888   static void test_cp_scl(char[] a, char[] b) {

   889     for (int i = 0; i*SCALE < a.length; i+=1) {

   890       a[i*SCALE] = b[i*SCALE];

   891     }

   892   }

   893   static void test_2ci_scl(char[] a, char[] b) {

   894     for (int i = 0; i*SCALE < a.length; i+=1) {

   895       a[i*SCALE] = (char)-123;

   896       b[i*SCALE] = (char)-103;

   897     }

   898   }

   899   static void test_2vi_scl(char[] a, char[] b, char c, char d) {

   900     for (int i = 0; i*SCALE < a.length; i+=1) {

   901       a[i*SCALE] = c;

   902       b[i*SCALE] = d;

   903     }

   904   }

   905   static void test_cp_alndst(char[] a, char[] b) {

   906     for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {

   907       a[i+ALIGN_OFF] = b[i];

   908     }

   909   }

   910   static void test_cp_alnsrc(char[] a, char[] b) {

   911     for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {

   912       a[i] = b[i+ALIGN_OFF];

   913     }

   914   }

   915   static void test_2ci_aln(char[] a, char[] b) {

   916     for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {

   917       a[i+ALIGN_OFF] = (char)-123;

   918       b[i] = (char)-103;

   919     }

   920   }

   921   static void test_2vi_aln(char[] a, char[] b, char c, char d) {

   922     for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {

   923       a[i] = c;

   924       b[i+ALIGN_OFF] = d;

   925     }

   926   }

   927   static void test_cp_unalndst(char[] a, char[] b) {

   928     for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {

   929       a[i+UNALIGN_OFF] = b[i];

   930     }

   931   }

   932   static void test_cp_unalnsrc(char[] a, char[] b) {

   933     for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {

   934       a[i] = b[i+UNALIGN_OFF];

   935     }

   936   }

   937   static void test_2ci_unaln(char[] a, char[] b) {

   938     for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {

   939       a[i+UNALIGN_OFF] = (char)-123;

   940       b[i] = (char)-103;

   941     }

   942   }

   943   static void test_2vi_unaln(char[] a, char[] b, char c, char d) {

   944     for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {

   945       a[i] = c;

   946       b[i+UNALIGN_OFF] = d;

   947     }

   948   }

   949 

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

   951     if (elem != val) {

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

   953       return 1;

   954     }

   955     return 0;

   956   }

   957 }