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 -XX:-TieredCompilation -XX:-OptimizeFill TestShortIntVect

    31  */

    32 

    33 public class TestShortIntVect {

    34   private static final int ARRLEN = 997;

    35   private static final int ITERS  = 11000;

    36   private static final int OFFSET = 3;

    37   private static final int SCALE = 2;

    38   private static final int ALIGN_OFF = 8;

    39   private static final int UNALIGN_OFF = 5;

    40 

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

    42     System.out.println("Testing Short + Integer vectors");

    43     int errn = test();

    44     if (errn > 0) {

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

    46       System.exit(97);

    47     }

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

    49   }

    50 

    51   static int test() {

    52     short[] a1 = new short[ARRLEN];

    53     short[] a2 = new short[ARRLEN];

    54     int[] b1 = new int[ARRLEN];

    55     int[] b2 = new int[ARRLEN];

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

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

    58       test_ci(a1, b1);

    59       test_vi(a2, b2, (short)123, (int)103);

    60       test_cp(a1, a2, b1, b2);

    61       test_ci_neg(a1, b1);

    62       test_vi_neg(a1, b1, (short)123, (int)103);

    63       test_cp_neg(a1, a2, b1, b2);

    64       test_ci_oppos(a1, b1);

    65       test_vi_oppos(a1, b1, (short)123, (int)103);

    66       test_cp_oppos(a1, a2, b1, b2);

    67       test_ci_aln(a1, b1);

    68       test_vi_aln(a1, b1, (short)123, (int)103);

    69       test_cp_alndst(a1, a2, b1, b2);

    70       test_cp_alnsrc(a1, a2, b1, b2);

    71       test_ci_unaln(a1, b1);

    72       test_vi_unaln(a1, b1, (short)123, (int)103);

    73       test_cp_unalndst(a1, a2, b1, b2);

    74       test_cp_unalnsrc(a1, a2, b1, b2);

    75     }

    76     // Initialize

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

    78       a1[i] = -1;

    79       a2[i] = -1;

    80       b1[i] = -1;

    81       b2[i] = -1;

    82     }

    83     // Test and verify results

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

    85     int errn = 0;

    86     {

    87       test_ci(a1, b1);

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

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

    90         errn += verify("test_ci: b1", i, b1[i], (int)-103);

    91       }

    92       test_vi(a2, b2, (short)123, (int)103);

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

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

    95         errn += verify("test_vi: b2", i, b2[i], (int)103);

    96       }

    97       test_cp(a1, a2, b1, b2);

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

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

   100         errn += verify("test_cp: b1", i, b1[i], (int)103);

   101       }

   102 

   103       // Reset for negative stride

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

   105         a1[i] = -1;

   106         a2[i] = -1;

   107         b1[i] = -1;

   108         b2[i] = -1;

   109       }

   110       test_ci_neg(a1, b1);

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

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

   113         errn += verify("test_ci_neg: b1", i, b1[i], (int)-103);

   114       }

   115       test_vi_neg(a2, b2, (short)123, (int)103);

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

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

   118         errn += verify("test_vi_neg: b2", i, b2[i], (int)103);

   119       }

   120       test_cp_neg(a1, a2, b1, b2);

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

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

   123         errn += verify("test_cp_neg: b1", i, b1[i], (int)103);

   124       }

   125 

   126       // Reset for opposite stride

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

   128         a1[i] = -1;

   129         a2[i] = -1;

   130         b1[i] = -1;

   131         b2[i] = -1;

   132       }

   133       test_ci_oppos(a1, b1);

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

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

   136         errn += verify("test_ci_oppos: b1", i, b1[i], (int)-103);

   137       }

   138       test_vi_oppos(a2, b2, (short)123, (int)103);

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

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

   141         errn += verify("test_vi_oppos: b2", i, b2[i], (int)103);

   142       }

   143       test_cp_oppos(a1, a2, b1, b2);

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

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

   146         errn += verify("test_cp_oppos: b1", i, b1[i], (int)103);

   147       }

   148 

   149       // Reset for 2 arrays with relative aligned offset

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

   151         a1[i] = -1;

   152         a2[i] = 123;

   153         b1[i] = -1;

   154         b2[i] = 123;

   155       }

   156       test_cp_alndst(a1, a2, b1, b2);

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

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

   159         errn += verify("test_cp_alndst: b1", i, b1[i], (int)-1);

   160       }

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

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

   163         errn += verify("test_cp_alndst: b1", i, b1[i], (int)123);

   164       }

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

   166         a2[i] = -123;

   167         b2[i] = -123;

   168       }

   169       test_cp_alnsrc(a1, a2, b1, b2);

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

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

   172         errn += verify("test_cp_alnsrc: b1", i, b1[i], (int)-123);

   173       }

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

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

   176         errn += verify("test_cp_alnsrc: b1", i, b1[i], (int)123);

   177       }

   178 

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

   180         a1[i] = -1;

   181         b1[i] = -1;

   182       }

   183       test_ci_aln(a1, b1);

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

   185         errn += verify("test_ci_aln: a1", i, a1[i], (short)-1);

   186       }

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

   188         errn += verify("test_ci_aln: a1", i, a1[i], (short)-123);

   189       }

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

   191         errn += verify("test_ci_aln: b1", i, b1[i], (int)-103);

   192       }

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

   194         errn += verify("test_ci_aln: b1", i, b1[i], (int)-1);

   195       }

   196 

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

   198         a1[i] = -1;

   199         b1[i] = -1;

   200       }

   201       test_vi_aln(a1, b1, (short)123, (int)103);

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

   203         errn += verify("test_vi_aln: a1", i, a1[i], (short)123);

   204       }

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

   206         errn += verify("test_vi_aln: a1", i, a1[i], (short)-1);

   207       }

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

   209         errn += verify("test_vi_aln: b1", i, b1[i], (int)-1);

   210       }

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

   212         errn += verify("test_vi_aln: b1", i, b1[i], (int)103);

   213       }

   214 

   215       // Reset for 2 arrays with relative unaligned offset

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

   217         a1[i] = -1;

   218         a2[i] = 123;

   219         b1[i] = -1;

   220         b2[i] = 123;

   221       }

   222       test_cp_unalndst(a1, a2, b1, b2);

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

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

   225         errn += verify("test_cp_unalndst: b1", i, b1[i], (int)-1);

   226       }

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

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

   229         errn += verify("test_cp_unalndst: b1", i, b1[i], (int)123);

   230       }

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

   232         a2[i] = -123;

   233         b2[i] = -123;

   234       }

   235       test_cp_unalnsrc(a1, a2, b1, b2);

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

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

   238         errn += verify("test_cp_unalnsrc: b1", i, b1[i], (int)-123);

   239       }

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

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

   242         errn += verify("test_cp_unalnsrc: b1", i, b1[i], (int)123);

   243       }

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

   245         a1[i] = -1;

   246         b1[i] = -1;

   247       }

   248       test_ci_unaln(a1, b1);

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

   250         errn += verify("test_ci_unaln: a1", i, a1[i], (short)-1);

   251       }

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

   253         errn += verify("test_ci_unaln: a1", i, a1[i], (short)-123);

   254       }

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

   256         errn += verify("test_ci_unaln: b1", i, b1[i], (int)-103);

   257       }

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

   259         errn += verify("test_ci_unaln: b1", i, b1[i], (int)-1);

   260       }

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

   262         a1[i] = -1;

   263         b1[i] = -1;

   264       }

   265       test_vi_unaln(a1, b1, (short)123, (int)103);

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

   267         errn += verify("test_vi_unaln: a1", i, a1[i], (short)123);

   268       }

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

   270         errn += verify("test_vi_unaln: a1", i, a1[i], (short)-1);

   271       }

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

   273         errn += verify("test_vi_unaln: b1", i, b1[i], (int)-1);

   274       }

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

   276         errn += verify("test_vi_unaln: b1", i, b1[i], (int)103);

   277       }

   278 

   279       // Reset for aligned overlap initialization

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

   281         a1[i] = (short)i;

   282         b1[i] = (int)i;

   283       }

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

   285         a1[i] = -1;

   286         b1[i] = -1;

   287       }

   288       test_cp_alndst(a1, a1, b1, b1);

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

   290         int v = i%ALIGN_OFF;

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

   292         errn += verify("test_cp_alndst_overlap: b1", i, b1[i], (int)v);

   293       }

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

   295         a1[i+ALIGN_OFF] = -1;

   296         b1[i+ALIGN_OFF] = -1;

   297       }

   298       test_cp_alnsrc(a1, a1, b1, b1);

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

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

   301         errn += verify("test_cp_alnsrc_overlap: b1", i, b1[i], (int)-1);

   302       }

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

   304         int v = i%ALIGN_OFF;

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

   306         errn += verify("test_cp_alnsrc_overlap: b1", i, b1[i], (int)v);

   307       }

   308 

   309       // Reset for unaligned overlap initialization

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

   311         a1[i] = (short)i;

   312         b1[i] = (int)i;

   313       }

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

   315         a1[i] = -1;

   316         b1[i] = -1;

   317       }

   318       test_cp_unalndst(a1, a1, b1, b1);

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

   320         int v = i%UNALIGN_OFF;

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

   322         errn += verify("test_cp_unalndst_overlap: b1", i, b1[i], (int)v);

   323       }

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

   325         a1[i+UNALIGN_OFF] = -1;

   326         b1[i+UNALIGN_OFF] = -1;

   327       }

   328       test_cp_unalnsrc(a1, a1, b1, b1);

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

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

   331         errn += verify("test_cp_unalnsrc_overlap: b1", i, b1[i], (int)-1);

   332       }

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

   334         int v = i%UNALIGN_OFF;

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

   336         errn += verify("test_cp_unalnsrc_overlap: b1", i, b1[i], (int)v);

   337       }

   338 

   339     }

   340 

   341     if (errn > 0)

   342       return errn;

   343 

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

   345     long start, end;

   346     start = System.currentTimeMillis();

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

   348       test_ci(a1, b1);

   349     }

   350     end = System.currentTimeMillis();

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

   352     start = System.currentTimeMillis();

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

   354       test_vi(a2, b2, (short)123, (int)103);

   355     }

   356     end = System.currentTimeMillis();

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

   358     start = System.currentTimeMillis();

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

   360       test_cp(a1, a2, b1, b2);

   361     }

   362     end = System.currentTimeMillis();

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

   364     start = System.currentTimeMillis();

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

   366       test_ci_neg(a1, b1);

   367     }

   368     end = System.currentTimeMillis();

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

   370     start = System.currentTimeMillis();

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

   372       test_vi_neg(a1, b1, (short)123, (int)103);

   373     }

   374     end = System.currentTimeMillis();

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

   376     start = System.currentTimeMillis();

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

   378       test_cp_neg(a1, a2, b1, b2);

   379     }

   380     end = System.currentTimeMillis();

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

   382     start = System.currentTimeMillis();

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

   384       test_ci_oppos(a1, b1);

   385     }

   386     end = System.currentTimeMillis();

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

   388     start = System.currentTimeMillis();

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

   390       test_vi_oppos(a1, b1, (short)123, (int)103);

   391     }

   392     end = System.currentTimeMillis();

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

   394     start = System.currentTimeMillis();

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

   396       test_cp_oppos(a1, a2, b1, b2);

   397     }

   398     end = System.currentTimeMillis();

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

   400     start = System.currentTimeMillis();

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

   402       test_ci_aln(a1, b1);

   403     }

   404     end = System.currentTimeMillis();

   405     System.out.println("test_ci_aln: " + (end - start));

   406     start = System.currentTimeMillis();

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

   408       test_vi_aln(a1, b1, (short)123, (int)103);

   409     }

   410     end = System.currentTimeMillis();

   411     System.out.println("test_vi_aln: " + (end - start));

   412     start = System.currentTimeMillis();

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

   414       test_cp_alndst(a1, a2, b1, b2);

   415     }

   416     end = System.currentTimeMillis();

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

   418     start = System.currentTimeMillis();

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

   420       test_cp_alnsrc(a1, a2, b1, b2);

   421     }

   422     end = System.currentTimeMillis();

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

   424     start = System.currentTimeMillis();

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

   426       test_ci_unaln(a1, b1);

   427     }

   428     end = System.currentTimeMillis();

   429     System.out.println("test_ci_unaln: " + (end - start));

   430     start = System.currentTimeMillis();

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

   432       test_vi_unaln(a1, b1, (short)123, (int)103);

   433     }

   434     end = System.currentTimeMillis();

   435     System.out.println("test_vi_unaln: " + (end - start));

   436     start = System.currentTimeMillis();

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

   438       test_cp_unalndst(a1, a2, b1, b2);

   439     }

   440     end = System.currentTimeMillis();

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

   442     start = System.currentTimeMillis();

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

   444       test_cp_unalnsrc(a1, a2, b1, b2);

   445     }

   446     end = System.currentTimeMillis();

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

   448     return errn;

   449   }

   450 

   451   static void test_ci(short[] a, int[] b) {

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

   453       a[i] = -123;

   454       b[i] = -103;

   455     }

   456   }

   457   static void test_vi(short[] a, int[] b, short c, int d) {

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

   459       a[i] = c;

   460       b[i] = d;

   461     }

   462   }

   463   static void test_cp(short[] a, short[] b, int[] c, int[] d) {

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

   465       a[i] = b[i];

   466       c[i] = d[i];

   467     }

   468   }

   469   static void test_ci_neg(short[] a, int[] b) {

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

   471       a[i] = -123;

   472       b[i] = -103;

   473     }

   474   }

   475   static void test_vi_neg(short[] a, int[] b, short c, int d) {

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

   477       a[i] = c;

   478       b[i] = d;

   479     }

   480   }

   481   static void test_cp_neg(short[] a, short[] b, int[] c, int[] d) {

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

   483       a[i] = b[i];

   484       c[i] = d[i];

   485     }

   486   }

   487   static void test_ci_oppos(short[] a, int[] b) {

   488     int limit = a.length-1;

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

   490       a[limit-i] = -123;

   491       b[i] = -103;

   492     }

   493   }

   494   static void test_vi_oppos(short[] a, int[] b, short c, int d) {

   495     int limit = a.length-1;

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

   497       a[i] = c;

   498       b[limit-i] = d;

   499     }

   500   }

   501   static void test_cp_oppos(short[] a, short[] b, int[] c, int[] d) {

   502     int limit = a.length-1;

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

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

   505       c[limit-i] = d[i];

   506     }

   507   }

   508   static void test_ci_aln(short[] a, int[] b) {

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

   510       a[i+ALIGN_OFF] = -123;

   511       b[i] = -103;

   512     }

   513   }

   514   static void test_vi_aln(short[] a, int[] b, short c, int d) {

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

   516       a[i] = c;

   517       b[i+ALIGN_OFF] = d;

   518     }

   519   }

   520   static void test_cp_alndst(short[] a, short[] b, int[] c, int[] d) {

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

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

   523       c[i+ALIGN_OFF] = d[i];

   524     }

   525   }

   526   static void test_cp_alnsrc(short[] a, short[] b, int[] c, int[] d) {

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

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

   529       c[i] = d[i+ALIGN_OFF];

   530     }

   531   }

   532   static void test_ci_unaln(short[] a, int[] b) {

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

   534       a[i+UNALIGN_OFF] = -123;

   535       b[i] = -103;

   536     }

   537   }

   538   static void test_vi_unaln(short[] a, int[] b, short c, int d) {

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

   540       a[i] = c;

   541       b[i+UNALIGN_OFF] = d;

   542     }

   543   }

   544   static void test_cp_unalndst(short[] a, short[] b, int[] c, int[] d) {

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

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

   547       c[i+UNALIGN_OFF] = d[i];

   548     }

   549   }

   550   static void test_cp_unalnsrc(short[] a, short[] b, int[] c, int[] d) {

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

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

   553       c[i] = d[i+UNALIGN_OFF];

   554     }

   555   }

   556 

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

   558     if (elem != val) {

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

   560       return 1;

   561     }

   562     return 0;

   563   }

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

   565     if (elem != val) {

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

   567       return 1;

   568     }

   569     return 0;

   570   }

   571 }