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 TestByteIntVect
  31  */
  32 
  33 public class TestByteIntVect {
  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 Byte + 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     byte[] a1 = new byte[ARRLEN];
  53     byte[] a2 = new byte[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, (byte)123, (int)103);
  60       test_cp(a1, a2, b1, b2);
  61       test_ci_neg(a1, b1);
  62       test_vi_neg(a1, b1, (byte)123, (int)103);
  63       test_cp_neg(a1, a2, b1, b2);
  64       test_ci_oppos(a1, b1);
  65       test_vi_oppos(a1, b1, (byte)123, (int)103);
  66       test_cp_oppos(a1, a2, b1, b2);
  67       test_ci_aln(a1, b1);
  68       test_vi_aln(a1, b1, (byte)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, (byte)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], (byte)-123);
  90         errn += verify("test_ci: b1", i, b1[i], (int)-103);
  91       }
  92       test_vi(a2, b2, (byte)123, (int)103);
  93       for (int i=0; i<ARRLEN; i++) {
  94         errn += verify("test_vi: a2", i, a2[i], (byte)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], (byte)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], (byte)-123);
 113         errn += verify("test_ci_neg: b1", i, b1[i], (int)-103);
 114       }
 115       test_vi_neg(a2, b2, (byte)123, (int)103);
 116       for (int i=0; i<ARRLEN; i++) {
 117         errn += verify("test_vi_neg: a2", i, a2[i], (byte)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], (byte)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], (byte)-123);
 136         errn += verify("test_ci_oppos: b1", i, b1[i], (int)-103);
 137       }
 138       test_vi_oppos(a2, b2, (byte)123, (int)103);
 139       for (int i=0; i<ARRLEN; i++) {
 140         errn += verify("test_vi_oppos: a2", i, a2[i], (byte)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], (byte)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], (byte)-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], (byte)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], (byte)-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], (byte)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], (byte)-1);
 186       }
 187       for (int i=ALIGN_OFF; i<ARRLEN; i++) {
 188         errn += verify("test_ci_aln: a1", i, a1[i], (byte)-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, (byte)123, (int)103);
 202       for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
 203         errn += verify("test_vi_aln: a1", i, a1[i], (byte)123);
 204       }
 205       for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
 206         errn += verify("test_vi_aln: a1", i, a1[i], (byte)-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], (byte)-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], (byte)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], (byte)-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], (byte)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], (byte)-1);
 251       }
 252       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
 253         errn += verify("test_ci_unaln: a1", i, a1[i], (byte)-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, (byte)123, (int)103);
 266       for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
 267         errn += verify("test_vi_unaln: a1", i, a1[i], (byte)123);
 268       }
 269       for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
 270         errn += verify("test_vi_unaln: a1", i, a1[i], (byte)-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] = (byte)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], (byte)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], (byte)-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], (byte)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] = (byte)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], (byte)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], (byte)-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], (byte)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, (byte)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, (byte)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, (byte)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, (byte)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, (byte)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(byte[] 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(byte[] a, int[] b, byte 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(byte[] a, byte[] 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(byte[] 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(byte[] a, int[] b, byte 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(byte[] a, byte[] 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(byte[] 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(byte[] a, int[] b, byte 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(byte[] a, byte[] 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(byte[] 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(byte[] a, int[] b, byte 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(byte[] a, byte[] 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(byte[] a, byte[] 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(byte[] 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(byte[] a, int[] b, byte 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(byte[] a, byte[] 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(byte[] a, byte[] 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, byte elem, byte 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 }