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.TestShortFloatVect
  33  */
  34 
  35 package compiler.codegen;
  36 
  37 public class TestShortFloatVect {
  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 Short + Float 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     short[] a1 = new short[ARRLEN];
  57     short[] a2 = new short[ARRLEN];
  58     float[] b1 = new float[ARRLEN];
  59     float[] b2 = new float[ARRLEN];
  60     System.out.println("Warmup");
  61     for (int i=0; i<ITERS; i++) {
  62       test_ci(a1, b1);
  63       test_vi(a2, b2, (short)123, 103.f);
  64       test_cp(a1, a2, b1, b2);
  65       test_ci_neg(a1, b1);
  66       test_vi_neg(a1, b1, (short)123, 103.f);
  67       test_cp_neg(a1, a2, b1, b2);
  68       test_ci_oppos(a1, b1);
  69       test_vi_oppos(a1, b1, (short)123, 103.f);
  70       test_cp_oppos(a1, a2, b1, b2);
  71       test_ci_aln(a1, b1);
  72       test_vi_aln(a1, b1, (short)123, 103.f);
  73       test_cp_alndst(a1, a2, b1, b2);
  74       test_cp_alnsrc(a1, a2, b1, b2);
  75       test_ci_unaln(a1, b1);
  76       test_vi_unaln(a1, b1, (short)123, 103.f);
  77       test_cp_unalndst(a1, a2, b1, b2);
  78       test_cp_unalnsrc(a1, a2, b1, b2);
  79     }
  80     // Initialize
  81     for (int i=0; i<ARRLEN; i++) {
  82       a1[i] = -1;
  83       a2[i] = -1;
  84       b1[i] = -1.f;
  85       b2[i] = -1.f;
  86     }
  87     // Test and verify results
  88     System.out.println("Verification");
  89     int errn = 0;
  90     {
  91       test_ci(a1, b1);
  92       for (int i=0; i<ARRLEN; i++) {
  93         errn += verify("test_ci: a1", i, a1[i], (short)-123);
  94         errn += verify("test_ci: b1", i, b1[i], -103.f);
  95       }
  96       test_vi(a2, b2, (short)123, 103.f);
  97       for (int i=0; i<ARRLEN; i++) {
  98         errn += verify("test_vi: a2", i, a2[i], (short)123);
  99         errn += verify("test_vi: b2", i, b2[i], 103.f);
 100       }
 101       test_cp(a1, a2, b1, b2);
 102       for (int i=0; i<ARRLEN; i++) {
 103         errn += verify("test_cp: a1", i, a1[i], (short)123);
 104         errn += verify("test_cp: b1", i, b1[i], 103.f);
 105       }
 106 
 107       // Reset for negative stride
 108       for (int i=0; i<ARRLEN; i++) {
 109         a1[i] = -1;
 110         a2[i] = -1;
 111         b1[i] = -1.f;
 112         b2[i] = -1.f;
 113       }
 114       test_ci_neg(a1, b1);
 115       for (int i=0; i<ARRLEN; i++) {
 116         errn += verify("test_ci_neg: a1", i, a1[i], (short)-123);
 117         errn += verify("test_ci_neg: b1", i, b1[i], -103.f);
 118       }
 119       test_vi_neg(a2, b2, (short)123, 103.f);
 120       for (int i=0; i<ARRLEN; i++) {
 121         errn += verify("test_vi_neg: a2", i, a2[i], (short)123);
 122         errn += verify("test_vi_neg: b2", i, b2[i], 103.f);
 123       }
 124       test_cp_neg(a1, a2, b1, b2);
 125       for (int i=0; i<ARRLEN; i++) {
 126         errn += verify("test_cp_neg: a1", i, a1[i], (short)123);
 127         errn += verify("test_cp_neg: b1", i, b1[i], 103.f);
 128       }
 129 
 130       // Reset for opposite stride
 131       for (int i=0; i<ARRLEN; i++) {
 132         a1[i] = -1;
 133         a2[i] = -1;
 134         b1[i] = -1.f;
 135         b2[i] = -1.f;
 136       }
 137       test_ci_oppos(a1, b1);
 138       for (int i=0; i<ARRLEN; i++) {
 139         errn += verify("test_ci_oppos: a1", i, a1[i], (short)-123);
 140         errn += verify("test_ci_oppos: b1", i, b1[i], -103.f);
 141       }
 142       test_vi_oppos(a2, b2, (short)123, 103.f);
 143       for (int i=0; i<ARRLEN; i++) {
 144         errn += verify("test_vi_oppos: a2", i, a2[i], (short)123);
 145         errn += verify("test_vi_oppos: b2", i, b2[i], 103.f);
 146       }
 147       test_cp_oppos(a1, a2, b1, b2);
 148       for (int i=0; i<ARRLEN; i++) {
 149         errn += verify("test_cp_oppos: a1", i, a1[i], (short)123);
 150         errn += verify("test_cp_oppos: b1", i, b1[i], 103.f);
 151       }
 152 
 153       // Reset for 2 arrays with relative aligned offset
 154       for (int i=0; i<ARRLEN; i++) {
 155         a1[i] = -1;
 156         a2[i] = 123;
 157         b1[i] = -1.f;
 158         b2[i] = 123.f;
 159       }
 160       test_cp_alndst(a1, a2, b1, b2);
 161       for (int i=0; i<ALIGN_OFF; i++) {
 162         errn += verify("test_cp_alndst: a1", i, a1[i], (short)-1);
 163         errn += verify("test_cp_alndst: b1", i, b1[i], -1.f);
 164       }
 165       for (int i=ALIGN_OFF; i<ARRLEN; i++) {
 166         errn += verify("test_cp_alndst: a1", i, a1[i], (short)123);
 167         errn += verify("test_cp_alndst: b1", i, b1[i], 123.f);
 168       }
 169       for (int i=0; i<ARRLEN; i++) {
 170         a2[i] = -123;
 171         b2[i] = -123.f;
 172       }
 173       test_cp_alnsrc(a1, a2, b1, b2);
 174       for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
 175         errn += verify("test_cp_alnsrc: a1", i, a1[i], (short)-123);
 176         errn += verify("test_cp_alnsrc: b1", i, b1[i], -123.f);
 177       }
 178       for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
 179         errn += verify("test_cp_alnsrc: a1", i, a1[i], (short)123);
 180         errn += verify("test_cp_alnsrc: b1", i, b1[i], 123.f);
 181       }
 182 
 183       for (int i=0; i<ARRLEN; i++) {
 184         a1[i] = -1;
 185         b1[i] = -1.f;
 186       }
 187       test_ci_aln(a1, b1);
 188       for (int i=0; i<ALIGN_OFF; i++) {
 189         errn += verify("test_ci_aln: a1", i, a1[i], (short)-1);
 190       }
 191       for (int i=ALIGN_OFF; i<ARRLEN; i++) {
 192         errn += verify("test_ci_aln: a1", i, a1[i], (short)-123);
 193       }
 194       for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
 195         errn += verify("test_ci_aln: b1", i, b1[i], -103.f);
 196       }
 197       for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
 198         errn += verify("test_ci_aln: b1", i, b1[i], -1.f);
 199       }
 200 
 201       for (int i=0; i<ARRLEN; i++) {
 202         a1[i] = -1;
 203         b1[i] = -1.f;
 204       }
 205       test_vi_aln(a1, b1, (short)123, 103.f);
 206       for (int i=0; i<ARRLEN-ALIGN_OFF; i++) {
 207         errn += verify("test_vi_aln: a1", i, a1[i], (short)123);
 208       }
 209       for (int i=ARRLEN-ALIGN_OFF; i<ARRLEN; i++) {
 210         errn += verify("test_vi_aln: a1", i, a1[i], (short)-1);
 211       }
 212       for (int i=0; i<ALIGN_OFF; i++) {
 213         errn += verify("test_vi_aln: b1", i, b1[i], -1.f);
 214       }
 215       for (int i=ALIGN_OFF; i<ARRLEN; i++) {
 216         errn += verify("test_vi_aln: b1", i, b1[i], 103.f);
 217       }
 218 
 219       // Reset for 2 arrays with relative unaligned offset
 220       for (int i=0; i<ARRLEN; i++) {
 221         a1[i] = -1;
 222         a2[i] = 123;
 223         b1[i] = -1.f;
 224         b2[i] = 123.f;
 225       }
 226       test_cp_unalndst(a1, a2, b1, b2);
 227       for (int i=0; i<UNALIGN_OFF; i++) {
 228         errn += verify("test_cp_unalndst: a1", i, a1[i], (short)-1);
 229         errn += verify("test_cp_unalndst: b1", i, b1[i], -1.f);
 230       }
 231       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
 232         errn += verify("test_cp_unalndst: a1", i, a1[i], (short)123);
 233         errn += verify("test_cp_unalndst: b1", i, b1[i], 123.f);
 234       }
 235       for (int i=0; i<ARRLEN; i++) {
 236         a2[i] = -123;
 237         b2[i] = -123.f;
 238       }
 239       test_cp_unalnsrc(a1, a2, b1, b2);
 240       for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
 241         errn += verify("test_cp_unalnsrc: a1", i, a1[i], (short)-123);
 242         errn += verify("test_cp_unalnsrc: b1", i, b1[i], -123.f);
 243       }
 244       for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
 245         errn += verify("test_cp_unalnsrc: a1", i, a1[i], (short)123);
 246         errn += verify("test_cp_unalnsrc: b1", i, b1[i], 123.f);
 247       }
 248       for (int i=0; i<ARRLEN; i++) {
 249         a1[i] = -1;
 250         b1[i] = -1;
 251       }
 252       test_ci_unaln(a1, b1);
 253       for (int i=0; i<UNALIGN_OFF; i++) {
 254         errn += verify("test_ci_unaln: a1", i, a1[i], (short)-1);
 255       }
 256       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
 257         errn += verify("test_ci_unaln: a1", i, a1[i], (short)-123);
 258       }
 259       for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
 260         errn += verify("test_ci_unaln: b1", i, b1[i], -103.f);
 261       }
 262       for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
 263         errn += verify("test_ci_unaln: b1", i, b1[i], -1.f);
 264       }
 265       for (int i=0; i<ARRLEN; i++) {
 266         a1[i] = -1;
 267         b1[i] = -1;
 268       }
 269       test_vi_unaln(a1, b1, (short)123, 103.f);
 270       for (int i=0; i<ARRLEN-UNALIGN_OFF; i++) {
 271         errn += verify("test_vi_unaln: a1", i, a1[i], (short)123);
 272       }
 273       for (int i=ARRLEN-UNALIGN_OFF; i<ARRLEN; i++) {
 274         errn += verify("test_vi_unaln: a1", i, a1[i], (short)-1);
 275       }
 276       for (int i=0; i<UNALIGN_OFF; i++) {
 277         errn += verify("test_vi_unaln: b1", i, b1[i], -1.f);
 278       }
 279       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
 280         errn += verify("test_vi_unaln: b1", i, b1[i], 103.f);
 281       }
 282 
 283       // Reset for aligned overlap initialization
 284       for (int i=0; i<ALIGN_OFF; i++) {
 285         a1[i] = (short)i;
 286         b1[i] = (float)i;
 287       }
 288       for (int i=ALIGN_OFF; i<ARRLEN; i++) {
 289         a1[i] = -1;
 290         b1[i] = -1.f;
 291       }
 292       test_cp_alndst(a1, a1, b1, b1);
 293       for (int i=0; i<ARRLEN; i++) {
 294         int v = i%ALIGN_OFF;
 295         errn += verify("test_cp_alndst_overlap: a1", i, a1[i], (short)v);
 296         errn += verify("test_cp_alndst_overlap: b1", i, b1[i], (float)v);
 297       }
 298       for (int i=0; i<ALIGN_OFF; i++) {
 299         a1[i+ALIGN_OFF] = -1;
 300         b1[i+ALIGN_OFF] = -1.f;
 301       }
 302       test_cp_alnsrc(a1, a1, b1, b1);
 303       for (int i=0; i<ALIGN_OFF; i++) {
 304         errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], (short)-1);
 305         errn += verify("test_cp_alnsrc_overlap: b1", i, b1[i], -1.f);
 306       }
 307       for (int i=ALIGN_OFF; i<ARRLEN; i++) {
 308         int v = i%ALIGN_OFF;
 309         errn += verify("test_cp_alnsrc_overlap: a1", i, a1[i], (short)v);
 310         errn += verify("test_cp_alnsrc_overlap: b1", i, b1[i], (float)v);
 311       }
 312 
 313       // Reset for unaligned overlap initialization
 314       for (int i=0; i<UNALIGN_OFF; i++) {
 315         a1[i] = (short)i;
 316         b1[i] = (float)i;
 317       }
 318       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
 319         a1[i] = -1;
 320         b1[i] = -1.f;
 321       }
 322       test_cp_unalndst(a1, a1, b1, b1);
 323       for (int i=0; i<ARRLEN; i++) {
 324         int v = i%UNALIGN_OFF;
 325         errn += verify("test_cp_unalndst_overlap: a1", i, a1[i], (short)v);
 326         errn += verify("test_cp_unalndst_overlap: b1", i, b1[i], (float)v);
 327       }
 328       for (int i=0; i<UNALIGN_OFF; i++) {
 329         a1[i+UNALIGN_OFF] = -1;
 330         b1[i+UNALIGN_OFF] = -1.f;
 331       }
 332       test_cp_unalnsrc(a1, a1, b1, b1);
 333       for (int i=0; i<UNALIGN_OFF; i++) {
 334         errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], (short)-1);
 335         errn += verify("test_cp_unalnsrc_overlap: b1", i, b1[i], -1.f);
 336       }
 337       for (int i=UNALIGN_OFF; i<ARRLEN; i++) {
 338         int v = i%UNALIGN_OFF;
 339         errn += verify("test_cp_unalnsrc_overlap: a1", i, a1[i], (short)v);
 340         errn += verify("test_cp_unalnsrc_overlap: b1", i, b1[i], (float)v);
 341       }
 342 
 343     }
 344 
 345     if (errn > 0)
 346       return errn;
 347 
 348     System.out.println("Time");
 349     long start, end;
 350     start = System.currentTimeMillis();
 351     for (int i=0; i<ITERS; i++) {
 352       test_ci(a1, b1);
 353     }
 354     end = System.currentTimeMillis();
 355     System.out.println("test_ci: " + (end - start));
 356     start = System.currentTimeMillis();
 357     for (int i=0; i<ITERS; i++) {
 358       test_vi(a2, b2, (short)123, 103.f);
 359     }
 360     end = System.currentTimeMillis();
 361     System.out.println("test_vi: " + (end - start));
 362     start = System.currentTimeMillis();
 363     for (int i=0; i<ITERS; i++) {
 364       test_cp(a1, a2, b1, b2);
 365     }
 366     end = System.currentTimeMillis();
 367     System.out.println("test_cp: " + (end - start));
 368     start = System.currentTimeMillis();
 369     for (int i=0; i<ITERS; i++) {
 370       test_ci_neg(a1, b1);
 371     }
 372     end = System.currentTimeMillis();
 373     System.out.println("test_ci_neg: " + (end - start));
 374     start = System.currentTimeMillis();
 375     for (int i=0; i<ITERS; i++) {
 376       test_vi_neg(a1, b1, (short)123, 103.f);
 377     }
 378     end = System.currentTimeMillis();
 379     System.out.println("test_vi_neg: " + (end - start));
 380     start = System.currentTimeMillis();
 381     for (int i=0; i<ITERS; i++) {
 382       test_cp_neg(a1, a2, b1, b2);
 383     }
 384     end = System.currentTimeMillis();
 385     System.out.println("test_cp_neg: " + (end - start));
 386     start = System.currentTimeMillis();
 387     for (int i=0; i<ITERS; i++) {
 388       test_ci_oppos(a1, b1);
 389     }
 390     end = System.currentTimeMillis();
 391     System.out.println("test_ci_oppos: " + (end - start));
 392     start = System.currentTimeMillis();
 393     for (int i=0; i<ITERS; i++) {
 394       test_vi_oppos(a1, b1, (short)123, 103.f);
 395     }
 396     end = System.currentTimeMillis();
 397     System.out.println("test_vi_oppos: " + (end - start));
 398     start = System.currentTimeMillis();
 399     for (int i=0; i<ITERS; i++) {
 400       test_cp_oppos(a1, a2, b1, b2);
 401     }
 402     end = System.currentTimeMillis();
 403     System.out.println("test_cp_oppos: " + (end - start));
 404     start = System.currentTimeMillis();
 405     for (int i=0; i<ITERS; i++) {
 406       test_ci_aln(a1, b1);
 407     }
 408     end = System.currentTimeMillis();
 409     System.out.println("test_ci_aln: " + (end - start));
 410     start = System.currentTimeMillis();
 411     for (int i=0; i<ITERS; i++) {
 412       test_vi_aln(a1, b1, (short)123, 103.f);
 413     }
 414     end = System.currentTimeMillis();
 415     System.out.println("test_vi_aln: " + (end - start));
 416     start = System.currentTimeMillis();
 417     for (int i=0; i<ITERS; i++) {
 418       test_cp_alndst(a1, a2, b1, b2);
 419     }
 420     end = System.currentTimeMillis();
 421     System.out.println("test_cp_alndst: " + (end - start));
 422     start = System.currentTimeMillis();
 423     for (int i=0; i<ITERS; i++) {
 424       test_cp_alnsrc(a1, a2, b1, b2);
 425     }
 426     end = System.currentTimeMillis();
 427     System.out.println("test_cp_alnsrc: " + (end - start));
 428     start = System.currentTimeMillis();
 429     for (int i=0; i<ITERS; i++) {
 430       test_ci_unaln(a1, b1);
 431     }
 432     end = System.currentTimeMillis();
 433     System.out.println("test_ci_unaln: " + (end - start));
 434     start = System.currentTimeMillis();
 435     for (int i=0; i<ITERS; i++) {
 436       test_vi_unaln(a1, b1, (short)123, 103.f);
 437     }
 438     end = System.currentTimeMillis();
 439     System.out.println("test_vi_unaln: " + (end - start));
 440     start = System.currentTimeMillis();
 441     for (int i=0; i<ITERS; i++) {
 442       test_cp_unalndst(a1, a2, b1, b2);
 443     }
 444     end = System.currentTimeMillis();
 445     System.out.println("test_cp_unalndst: " + (end - start));
 446     start = System.currentTimeMillis();
 447     for (int i=0; i<ITERS; i++) {
 448       test_cp_unalnsrc(a1, a2, b1, b2);
 449     }
 450     end = System.currentTimeMillis();
 451     System.out.println("test_cp_unalnsrc: " + (end - start));
 452     return errn;
 453   }
 454 
 455   static void test_ci(short[] a, float[] b) {
 456     for (int i = 0; i < a.length; i+=1) {
 457       a[i] = -123;
 458       b[i] = -103.f;
 459     }
 460   }
 461   static void test_vi(short[] a, float[] b, short c, float d) {
 462     for (int i = 0; i < a.length; i+=1) {
 463       a[i] = c;
 464       b[i] = d;
 465     }
 466   }
 467   static void test_cp(short[] a, short[] b, float[] c, float[] d) {
 468     for (int i = 0; i < a.length; i+=1) {
 469       a[i] = b[i];
 470       c[i] = d[i];
 471     }
 472   }
 473   static void test_ci_neg(short[] a, float[] b) {
 474     for (int i = a.length-1; i >= 0; i-=1) {
 475       a[i] = -123;
 476       b[i] = -103.f;
 477     }
 478   }
 479   static void test_vi_neg(short[] a, float[] b, short c, float d) {
 480     for (int i = a.length-1; i >= 0; i-=1) {
 481       a[i] = c;
 482       b[i] = d;
 483     }
 484   }
 485   static void test_cp_neg(short[] a, short[] b, float[] c, float[] d) {
 486     for (int i = a.length-1; i >= 0; i-=1) {
 487       a[i] = b[i];
 488       c[i] = d[i];
 489     }
 490   }
 491   static void test_ci_oppos(short[] a, float[] b) {
 492     int limit = a.length-1;
 493     for (int i = 0; i < a.length; i+=1) {
 494       a[limit-i] = -123;
 495       b[i] = -103.f;
 496     }
 497   }
 498   static void test_vi_oppos(short[] a, float[] b, short c, float d) {
 499     int limit = a.length-1;
 500     for (int i = a.length-1; i >= 0; i-=1) {
 501       a[i] = c;
 502       b[limit-i] = d;
 503     }
 504   }
 505   static void test_cp_oppos(short[] a, short[] b, float[] c, float[] d) {
 506     int limit = a.length-1;
 507     for (int i = 0; i < a.length; i+=1) {
 508       a[i] = b[limit-i];
 509       c[limit-i] = d[i];
 510     }
 511   }
 512   static void test_ci_aln(short[] a, float[] b) {
 513     for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
 514       a[i+ALIGN_OFF] = -123;
 515       b[i] = -103.f;
 516     }
 517   }
 518   static void test_vi_aln(short[] a, float[] b, short c, float d) {
 519     for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
 520       a[i] = c;
 521       b[i+ALIGN_OFF] = d;
 522     }
 523   }
 524   static void test_cp_alndst(short[] a, short[] b, float[] c, float[] d) {
 525     for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
 526       a[i+ALIGN_OFF] = b[i];
 527       c[i+ALIGN_OFF] = d[i];
 528     }
 529   }
 530   static void test_cp_alnsrc(short[] a, short[] b, float[] c, float[] d) {
 531     for (int i = 0; i < a.length-ALIGN_OFF; i+=1) {
 532       a[i] = b[i+ALIGN_OFF];
 533       c[i] = d[i+ALIGN_OFF];
 534     }
 535   }
 536   static void test_ci_unaln(short[] a, float[] b) {
 537     for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
 538       a[i+UNALIGN_OFF] = -123;
 539       b[i] = -103.f;
 540     }
 541   }
 542   static void test_vi_unaln(short[] a, float[] b, short c, float d) {
 543     for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
 544       a[i] = c;
 545       b[i+UNALIGN_OFF] = d;
 546     }
 547   }
 548   static void test_cp_unalndst(short[] a, short[] b, float[] c, float[] d) {
 549     for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
 550       a[i+UNALIGN_OFF] = b[i];
 551       c[i+UNALIGN_OFF] = d[i];
 552     }
 553   }
 554   static void test_cp_unalnsrc(short[] a, short[] b, float[] c, float[] d) {
 555     for (int i = 0; i < a.length-UNALIGN_OFF; i+=1) {
 556       a[i] = b[i+UNALIGN_OFF];
 557       c[i] = d[i+UNALIGN_OFF];
 558     }
 559   }
 560 
 561   static int verify(String text, int i, short elem, short val) {
 562     if (elem != val) {
 563       System.err.println(text + "[" + i + "] = " + elem + " != " + val);
 564       return 1;
 565     }
 566     return 0;
 567   }
 568   static int verify(String text, int i, float elem, float val) {
 569     if (elem != val) {
 570       System.err.println(text + "[" + i + "] = " + elem + " != " + val);
 571       return 1;
 572     }
 573     return 0;
 574   }
 575 }