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  * @test
  26  * @bug 6340864
  27  * @summary Implement vectorization optimizations in hotspot-server
  28  *
  29  * @run main/othervm/timeout=400 -Xbatch -Xmx128m compiler.c2.cr6340864.TestFloatVect
  30  * @run main/othervm/timeout=400 -Xbatch -Xmx128m -XX:MaxVectorSize=8 compiler.c2.cr6340864.TestFloatVect
  31  * @run main/othervm/timeout=400 -Xbatch -Xmx128m -XX:MaxVectorSize=16 compiler.c2.cr6340864.TestFloatVect
  32  * @run main/othervm/timeout=400 -Xbatch -Xmx128m -XX:MaxVectorSize=32 compiler.c2.cr6340864.TestFloatVect
  33  */
  34 
  35 package compiler.c2.cr6340864;
  36 
  37 public class TestFloatVect {
  38   private static final int ARRLEN = 997;
  39   private static final int ITERS  = 11000;
  40   private static final float ADD_INIT = -7500.f;
  41   private static final float VALUE = 15.f;
  42 
  43   public static void main(String args[]) {
  44     System.out.println("Testing Float vectors");
  45     int errn = test();
  46     if (errn > 0) {
  47       System.err.println("FAILED: " + errn + " errors");
  48       System.exit(97);
  49     }
  50     System.out.println("PASSED");
  51   }
  52 
  53   static int test() {
  54     float[] a0 = new float[ARRLEN];
  55     float[] a1 = new float[ARRLEN];
  56     float[] a2 = new float[ARRLEN];
  57     float[] a3 = new float[ARRLEN];
  58     // Initialize
  59     float gold_sum = 0;
  60     for (int i=0; i<ARRLEN; i++) {
  61       float val = ADD_INIT+(float)i;
  62       gold_sum += val;
  63       a1[i] = val;
  64       a2[i] = VALUE;
  65       a3[i] = -VALUE;
  66     }
  67 
  68     System.out.println("Warmup");
  69     for (int i=0; i<ITERS; i++) {
  70       test_sum(a1);
  71       test_addc(a0, a1);
  72       test_addv(a0, a1, VALUE);
  73       test_adda(a0, a1, a2);
  74       test_subc(a0, a1);
  75       test_subv(a0, a1, VALUE);
  76       test_suba(a0, a1, a2);
  77       test_mulc(a0, a1);
  78       test_mulv(a0, a1, VALUE);
  79       test_mula(a0, a1, a2);
  80       test_divc(a0, a1);
  81       test_divv(a0, a1, VALUE);
  82       test_diva(a0, a1, a2);
  83       test_mulc_n(a0, a1);
  84       test_mulv(a0, a1, -VALUE);
  85       test_mula(a0, a1, a3);
  86       test_divc_n(a0, a1);
  87       test_divv(a0, a1, -VALUE);
  88       test_diva(a0, a1, a3);
  89       test_negc(a0, a1);
  90     }
  91     // Test and verify results
  92     System.out.println("Verification");
  93     int errn = 0;
  94     {
  95       float sum = test_sum(a1);
  96       if (sum != gold_sum) {
  97         System.err.println("test_sum:  " + sum + " != " + gold_sum);
  98         errn++;
  99       }
 100       // Overwrite with NaN values
 101       a1[0] = Float.NaN;
 102       a1[1] = Float.POSITIVE_INFINITY;
 103       a1[2] = Float.NEGATIVE_INFINITY;
 104       a1[3] = Float.MAX_VALUE;
 105       a1[4] = Float.MIN_VALUE;
 106       a1[5] = Float.MIN_NORMAL;
 107 
 108       a2[6] = a1[0];
 109       a2[7] = a1[1];
 110       a2[8] = a1[2];
 111       a2[9] = a1[3];
 112       a2[10] = a1[4];
 113       a2[11] = a1[5];
 114 
 115       a3[6] = -a2[6];
 116       a3[7] = -a2[7];
 117       a3[8] = -a2[8];
 118       a3[9] = -a2[9];
 119       a3[10] = -a2[10];
 120       a3[11] = -a2[11];
 121 
 122       test_addc(a0, a1);
 123       errn += verify("test_addc: ", 0, a0[0], (Float.NaN+VALUE));
 124       errn += verify("test_addc: ", 1, a0[1], (Float.POSITIVE_INFINITY+VALUE));
 125       errn += verify("test_addc: ", 2, a0[2], (Float.NEGATIVE_INFINITY+VALUE));
 126       errn += verify("test_addc: ", 3, a0[3], (Float.MAX_VALUE+VALUE));
 127       errn += verify("test_addc: ", 4, a0[4], (Float.MIN_VALUE+VALUE));
 128       errn += verify("test_addc: ", 5, a0[5], (Float.MIN_NORMAL+VALUE));
 129       for (int i=6; i<ARRLEN; i++) {
 130         errn += verify("test_addc: ", i, a0[i], ((ADD_INIT+i)+VALUE));
 131       }
 132       test_addv(a0, a1, VALUE);
 133       errn += verify("test_addv: ", 0, a0[0], (Float.NaN+VALUE));
 134       errn += verify("test_addv: ", 1, a0[1], (Float.POSITIVE_INFINITY+VALUE));
 135       errn += verify("test_addv: ", 2, a0[2], (Float.NEGATIVE_INFINITY+VALUE));
 136       errn += verify("test_addv: ", 3, a0[3], (Float.MAX_VALUE+VALUE));
 137       errn += verify("test_addv: ", 4, a0[4], (Float.MIN_VALUE+VALUE));
 138       errn += verify("test_addv: ", 5, a0[5], (Float.MIN_NORMAL+VALUE));
 139       for (int i=6; i<ARRLEN; i++) {
 140         errn += verify("test_addv: ", i, a0[i], ((ADD_INIT+i)+VALUE));
 141       }
 142       test_adda(a0, a1, a2);
 143       errn += verify("test_adda: ", 0, a0[0], (Float.NaN+VALUE));
 144       errn += verify("test_adda: ", 1, a0[1], (Float.POSITIVE_INFINITY+VALUE));
 145       errn += verify("test_adda: ", 2, a0[2], (Float.NEGATIVE_INFINITY+VALUE));
 146       errn += verify("test_adda: ", 3, a0[3], (Float.MAX_VALUE+VALUE));
 147       errn += verify("test_adda: ", 4, a0[4], (Float.MIN_VALUE+VALUE));
 148       errn += verify("test_adda: ", 5, a0[5], (Float.MIN_NORMAL+VALUE));
 149       errn += verify("test_adda: ", 6, a0[6], ((ADD_INIT+6)+Float.NaN));
 150       errn += verify("test_adda: ", 7, a0[7], ((ADD_INIT+7)+Float.POSITIVE_INFINITY));
 151       errn += verify("test_adda: ", 8, a0[8], ((ADD_INIT+8)+Float.NEGATIVE_INFINITY));
 152       errn += verify("test_adda: ", 9, a0[9], ((ADD_INIT+9)+Float.MAX_VALUE));
 153       errn += verify("test_adda: ", 10, a0[10], ((ADD_INIT+10)+Float.MIN_VALUE));
 154       errn += verify("test_adda: ", 11, a0[11], ((ADD_INIT+11)+Float.MIN_NORMAL));
 155       for (int i=12; i<ARRLEN; i++) {
 156         errn += verify("test_adda: ", i, a0[i], ((ADD_INIT+i)+VALUE));
 157       }
 158 
 159       test_subc(a0, a1);
 160       errn += verify("test_subc: ", 0, a0[0], (Float.NaN-VALUE));
 161       errn += verify("test_subc: ", 1, a0[1], (Float.POSITIVE_INFINITY-VALUE));
 162       errn += verify("test_subc: ", 2, a0[2], (Float.NEGATIVE_INFINITY-VALUE));
 163       errn += verify("test_subc: ", 3, a0[3], (Float.MAX_VALUE-VALUE));
 164       errn += verify("test_subc: ", 4, a0[4], (Float.MIN_VALUE-VALUE));
 165       errn += verify("test_subc: ", 5, a0[5], (Float.MIN_NORMAL-VALUE));
 166       for (int i=6; i<ARRLEN; i++) {
 167         errn += verify("test_subc: ", i, a0[i], ((ADD_INIT+i)-VALUE));
 168       }
 169       test_subv(a0, a1, VALUE);
 170       errn += verify("test_subv: ", 0, a0[0], (Float.NaN-VALUE));
 171       errn += verify("test_subv: ", 1, a0[1], (Float.POSITIVE_INFINITY-VALUE));
 172       errn += verify("test_subv: ", 2, a0[2], (Float.NEGATIVE_INFINITY-VALUE));
 173       errn += verify("test_subv: ", 3, a0[3], (Float.MAX_VALUE-VALUE));
 174       errn += verify("test_subv: ", 4, a0[4], (Float.MIN_VALUE-VALUE));
 175       errn += verify("test_subv: ", 5, a0[5], (Float.MIN_NORMAL-VALUE));
 176       for (int i=6; i<ARRLEN; i++) {
 177         errn += verify("test_subv: ", i, a0[i], ((ADD_INIT+i)-VALUE));
 178       }
 179       test_suba(a0, a1, a2);
 180       errn += verify("test_suba: ", 0, a0[0], (Float.NaN-VALUE));
 181       errn += verify("test_suba: ", 1, a0[1], (Float.POSITIVE_INFINITY-VALUE));
 182       errn += verify("test_suba: ", 2, a0[2], (Float.NEGATIVE_INFINITY-VALUE));
 183       errn += verify("test_suba: ", 3, a0[3], (Float.MAX_VALUE-VALUE));
 184       errn += verify("test_suba: ", 4, a0[4], (Float.MIN_VALUE-VALUE));
 185       errn += verify("test_suba: ", 5, a0[5], (Float.MIN_NORMAL-VALUE));
 186       errn += verify("test_suba: ", 6, a0[6], ((ADD_INIT+6)-Float.NaN));
 187       errn += verify("test_suba: ", 7, a0[7], ((ADD_INIT+7)-Float.POSITIVE_INFINITY));
 188       errn += verify("test_suba: ", 8, a0[8], ((ADD_INIT+8)-Float.NEGATIVE_INFINITY));
 189       errn += verify("test_suba: ", 9, a0[9], ((ADD_INIT+9)-Float.MAX_VALUE));
 190       errn += verify("test_suba: ", 10, a0[10], ((ADD_INIT+10)-Float.MIN_VALUE));
 191       errn += verify("test_suba: ", 11, a0[11], ((ADD_INIT+11)-Float.MIN_NORMAL));
 192       for (int i=12; i<ARRLEN; i++) {
 193         errn += verify("test_suba: ", i, a0[i], ((ADD_INIT+i)-VALUE));
 194       }
 195 
 196       test_mulc(a0, a1);
 197       errn += verify("test_mulc: ", 0, a0[0], (Float.NaN*VALUE));
 198       errn += verify("test_mulc: ", 1, a0[1], (Float.POSITIVE_INFINITY*VALUE));
 199       errn += verify("test_mulc: ", 2, a0[2], (Float.NEGATIVE_INFINITY*VALUE));
 200       errn += verify("test_mulc: ", 3, a0[3], (Float.MAX_VALUE*VALUE));
 201       errn += verify("test_mulc: ", 4, a0[4], (Float.MIN_VALUE*VALUE));
 202       errn += verify("test_mulc: ", 5, a0[5], (Float.MIN_NORMAL*VALUE));
 203       for (int i=6; i<ARRLEN; i++) {
 204         errn += verify("test_mulc: ", i, a0[i], ((ADD_INIT+i)*VALUE));
 205       }
 206       test_mulv(a0, a1, VALUE);
 207       errn += verify("test_mulv: ", 0, a0[0], (Float.NaN*VALUE));
 208       errn += verify("test_mulv: ", 1, a0[1], (Float.POSITIVE_INFINITY*VALUE));
 209       errn += verify("test_mulv: ", 2, a0[2], (Float.NEGATIVE_INFINITY*VALUE));
 210       errn += verify("test_mulv: ", 3, a0[3], (Float.MAX_VALUE*VALUE));
 211       errn += verify("test_mulv: ", 4, a0[4], (Float.MIN_VALUE*VALUE));
 212       errn += verify("test_mulv: ", 5, a0[5], (Float.MIN_NORMAL*VALUE));
 213       for (int i=6; i<ARRLEN; i++) {
 214         errn += verify("test_mulv: ", i, a0[i], ((ADD_INIT+i)*VALUE));
 215       }
 216       test_mula(a0, a1, a2);
 217       errn += verify("test_mula: ", 0, a0[0], (Float.NaN*VALUE));
 218       errn += verify("test_mula: ", 1, a0[1], (Float.POSITIVE_INFINITY*VALUE));
 219       errn += verify("test_mula: ", 2, a0[2], (Float.NEGATIVE_INFINITY*VALUE));
 220       errn += verify("test_mula: ", 3, a0[3], (Float.MAX_VALUE*VALUE));
 221       errn += verify("test_mula: ", 4, a0[4], (Float.MIN_VALUE*VALUE));
 222       errn += verify("test_mula: ", 5, a0[5], (Float.MIN_NORMAL*VALUE));
 223       errn += verify("test_mula: ", 6, a0[6], ((ADD_INIT+6)*Float.NaN));
 224       errn += verify("test_mula: ", 7, a0[7], ((ADD_INIT+7)*Float.POSITIVE_INFINITY));
 225       errn += verify("test_mula: ", 8, a0[8], ((ADD_INIT+8)*Float.NEGATIVE_INFINITY));
 226       errn += verify("test_mula: ", 9, a0[9], ((ADD_INIT+9)*Float.MAX_VALUE));
 227       errn += verify("test_mula: ", 10, a0[10], ((ADD_INIT+10)*Float.MIN_VALUE));
 228       errn += verify("test_mula: ", 11, a0[11], ((ADD_INIT+11)*Float.MIN_NORMAL));
 229       for (int i=12; i<ARRLEN; i++) {
 230         errn += verify("test_mula: ", i, a0[i], ((ADD_INIT+i)*VALUE));
 231       }
 232 
 233       test_divc(a0, a1);
 234       errn += verify("test_divc: ", 0, a0[0], (Float.NaN/VALUE));
 235       errn += verify("test_divc: ", 1, a0[1], (Float.POSITIVE_INFINITY/VALUE));
 236       errn += verify("test_divc: ", 2, a0[2], (Float.NEGATIVE_INFINITY/VALUE));
 237       errn += verify("test_divc: ", 3, a0[3], (Float.MAX_VALUE/VALUE));
 238       errn += verify("test_divc: ", 4, a0[4], (Float.MIN_VALUE/VALUE));
 239       errn += verify("test_divc: ", 5, a0[5], (Float.MIN_NORMAL/VALUE));
 240       for (int i=6; i<ARRLEN; i++) {
 241         errn += verify("test_divc: ", i, a0[i], ((ADD_INIT+i)/VALUE));
 242       }
 243       test_divv(a0, a1, VALUE);
 244       errn += verify("test_divv: ", 0, a0[0], (Float.NaN/VALUE));
 245       errn += verify("test_divv: ", 1, a0[1], (Float.POSITIVE_INFINITY/VALUE));
 246       errn += verify("test_divv: ", 2, a0[2], (Float.NEGATIVE_INFINITY/VALUE));
 247       errn += verify("test_divv: ", 3, a0[3], (Float.MAX_VALUE/VALUE));
 248       errn += verify("test_divv: ", 4, a0[4], (Float.MIN_VALUE/VALUE));
 249       errn += verify("test_divv: ", 5, a0[5], (Float.MIN_NORMAL/VALUE));
 250       for (int i=6; i<ARRLEN; i++) {
 251         errn += verify("test_divv: ", i, a0[i], ((ADD_INIT+i)/VALUE));
 252       }
 253       test_diva(a0, a1, a2);
 254       errn += verify("test_diva: ", 0, a0[0], (Float.NaN/VALUE));
 255       errn += verify("test_diva: ", 1, a0[1], (Float.POSITIVE_INFINITY/VALUE));
 256       errn += verify("test_diva: ", 2, a0[2], (Float.NEGATIVE_INFINITY/VALUE));
 257       errn += verify("test_diva: ", 3, a0[3], (Float.MAX_VALUE/VALUE));
 258       errn += verify("test_diva: ", 4, a0[4], (Float.MIN_VALUE/VALUE));
 259       errn += verify("test_diva: ", 5, a0[5], (Float.MIN_NORMAL/VALUE));
 260       errn += verify("test_diva: ", 6, a0[6], ((ADD_INIT+6)/Float.NaN));
 261       errn += verify("test_diva: ", 7, a0[7], ((ADD_INIT+7)/Float.POSITIVE_INFINITY));
 262       errn += verify("test_diva: ", 8, a0[8], ((ADD_INIT+8)/Float.NEGATIVE_INFINITY));
 263       errn += verify("test_diva: ", 9, a0[9], ((ADD_INIT+9)/Float.MAX_VALUE));
 264       errn += verify("test_diva: ", 10, a0[10], ((ADD_INIT+10)/Float.MIN_VALUE));
 265       errn += verify("test_diva: ", 11, a0[11], ((ADD_INIT+11)/Float.MIN_NORMAL));
 266       for (int i=12; i<ARRLEN; i++) {
 267         errn += verify("test_diva: ", i, a0[i], ((ADD_INIT+i)/VALUE));
 268       }
 269 
 270       test_mulc_n(a0, a1);
 271       errn += verify("test_mulc_n: ", 0, a0[0], (Float.NaN*(-VALUE)));
 272       errn += verify("test_mulc_n: ", 1, a0[1], (Float.POSITIVE_INFINITY*(-VALUE)));
 273       errn += verify("test_mulc_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY*(-VALUE)));
 274       errn += verify("test_mulc_n: ", 3, a0[3], (Float.MAX_VALUE*(-VALUE)));
 275       errn += verify("test_mulc_n: ", 4, a0[4], (Float.MIN_VALUE*(-VALUE)));
 276       errn += verify("test_mulc_n: ", 5, a0[5], (Float.MIN_NORMAL*(-VALUE)));
 277       for (int i=6; i<ARRLEN; i++) {
 278         errn += verify("test_mulc_n: ", i, a0[i], ((ADD_INIT+i)*(-VALUE)));
 279       }
 280       test_mulv(a0, a1, -VALUE);
 281       errn += verify("test_mulv_n: ", 0, a0[0], (Float.NaN*(-VALUE)));
 282       errn += verify("test_mulv_n: ", 1, a0[1], (Float.POSITIVE_INFINITY*(-VALUE)));
 283       errn += verify("test_mulv_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY*(-VALUE)));
 284       errn += verify("test_mulv_n: ", 3, a0[3], (Float.MAX_VALUE*(-VALUE)));
 285       errn += verify("test_mulv_n: ", 4, a0[4], (Float.MIN_VALUE*(-VALUE)));
 286       errn += verify("test_mulv_n: ", 5, a0[5], (Float.MIN_NORMAL*(-VALUE)));
 287       for (int i=6; i<ARRLEN; i++) {
 288         errn += verify("test_mulv_n: ", i, a0[i], ((ADD_INIT+i)*(-VALUE)));
 289       }
 290       test_mula(a0, a1, a3);
 291       errn += verify("test_mula_n: ", 0, a0[0], (Float.NaN*(-VALUE)));
 292       errn += verify("test_mula_n: ", 1, a0[1], (Float.POSITIVE_INFINITY*(-VALUE)));
 293       errn += verify("test_mula_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY*(-VALUE)));
 294       errn += verify("test_mula_n: ", 3, a0[3], (Float.MAX_VALUE*(-VALUE)));
 295       errn += verify("test_mula_n: ", 4, a0[4], (Float.MIN_VALUE*(-VALUE)));
 296       errn += verify("test_mula_n: ", 5, a0[5], (Float.MIN_NORMAL*(-VALUE)));
 297       errn += verify("test_mula_n: ", 6, a0[6], ((ADD_INIT+6)*(-Float.NaN)));
 298       errn += verify("test_mula_n: ", 7, a0[7], ((ADD_INIT+7)*(-Float.POSITIVE_INFINITY)));
 299       errn += verify("test_mula_n: ", 8, a0[8], ((ADD_INIT+8)*(-Float.NEGATIVE_INFINITY)));
 300       errn += verify("test_mula_n: ", 9, a0[9], ((ADD_INIT+9)*(-Float.MAX_VALUE)));
 301       errn += verify("test_mula_n: ", 10, a0[10], ((ADD_INIT+10)*(-Float.MIN_VALUE)));
 302       errn += verify("test_mula_n: ", 11, a0[11], ((ADD_INIT+11)*(-Float.MIN_NORMAL)));
 303       for (int i=12; i<ARRLEN; i++) {
 304         errn += verify("test_mula_n: ", i, a0[i], ((ADD_INIT+i)*(-VALUE)));
 305       }
 306 
 307       test_divc_n(a0, a1);
 308       errn += verify("test_divc_n: ", 0, a0[0], (Float.NaN/(-VALUE)));
 309       errn += verify("test_divc_n: ", 1, a0[1], (Float.POSITIVE_INFINITY/(-VALUE)));
 310       errn += verify("test_divc_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY/(-VALUE)));
 311       errn += verify("test_divc_n: ", 3, a0[3], (Float.MAX_VALUE/(-VALUE)));
 312       errn += verify("test_divc_n: ", 4, a0[4], (Float.MIN_VALUE/(-VALUE)));
 313       errn += verify("test_divc_n: ", 5, a0[5], (Float.MIN_NORMAL/(-VALUE)));
 314       for (int i=6; i<ARRLEN; i++) {
 315         errn += verify("test_divc_n: ", i, a0[i], ((ADD_INIT+i)/(-VALUE)));
 316       }
 317       test_divv(a0, a1, -VALUE);
 318       errn += verify("test_divv_n: ", 0, a0[0], (Float.NaN/(-VALUE)));
 319       errn += verify("test_divv_n: ", 1, a0[1], (Float.POSITIVE_INFINITY/(-VALUE)));
 320       errn += verify("test_divv_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY/(-VALUE)));
 321       errn += verify("test_divv_n: ", 3, a0[3], (Float.MAX_VALUE/(-VALUE)));
 322       errn += verify("test_divv_n: ", 4, a0[4], (Float.MIN_VALUE/(-VALUE)));
 323       errn += verify("test_divv_n: ", 5, a0[5], (Float.MIN_NORMAL/(-VALUE)));
 324       for (int i=6; i<ARRLEN; i++) {
 325         errn += verify("test_divv_n: ", i, a0[i], ((ADD_INIT+i)/(-VALUE)));
 326       }
 327       test_diva(a0, a1, a3);
 328       errn += verify("test_diva_n: ", 0, a0[0], (Float.NaN/(-VALUE)));
 329       errn += verify("test_diva_n: ", 1, a0[1], (Float.POSITIVE_INFINITY/(-VALUE)));
 330       errn += verify("test_diva_n: ", 2, a0[2], (Float.NEGATIVE_INFINITY/(-VALUE)));
 331       errn += verify("test_diva_n: ", 3, a0[3], (Float.MAX_VALUE/(-VALUE)));
 332       errn += verify("test_diva_n: ", 4, a0[4], (Float.MIN_VALUE/(-VALUE)));
 333       errn += verify("test_diva_n: ", 5, a0[5], (Float.MIN_NORMAL/(-VALUE)));
 334       errn += verify("test_diva_n: ", 6, a0[6], ((ADD_INIT+6)/(-Float.NaN)));
 335       errn += verify("test_diva_n: ", 7, a0[7], ((ADD_INIT+7)/(-Float.POSITIVE_INFINITY)));
 336       errn += verify("test_diva_n: ", 8, a0[8], ((ADD_INIT+8)/(-Float.NEGATIVE_INFINITY)));
 337       errn += verify("test_diva_n: ", 9, a0[9], ((ADD_INIT+9)/(-Float.MAX_VALUE)));
 338       errn += verify("test_diva_n: ", 10, a0[10], ((ADD_INIT+10)/(-Float.MIN_VALUE)));
 339       errn += verify("test_diva_n: ", 11, a0[11], ((ADD_INIT+11)/(-Float.MIN_NORMAL)));
 340       for (int i=12; i<ARRLEN; i++) {
 341         errn += verify("test_diva_n: ", i, a0[i], ((ADD_INIT+i)/(-VALUE)));
 342       }
 343 
 344       test_negc(a0, a1);
 345       errn += verify("test_negc: ", 0, a0[0], (Float.NaN));
 346       errn += verify("test_negc: ", 1, a0[1], (Float.NEGATIVE_INFINITY));
 347       errn += verify("test_negc: ", 2, a0[2], (Float.POSITIVE_INFINITY));
 348       errn += verify("test_negc: ", 3, a0[3], (float)(-Float.MAX_VALUE));
 349       errn += verify("test_negc: ", 4, a0[4], (float)(-Float.MIN_VALUE));
 350       errn += verify("test_negc: ", 5, a0[5], (float)(-Float.MIN_NORMAL));
 351       for (int i=6; i<ARRLEN; i++) {
 352         errn += verify("test_negc: ", i, a0[i], (float)(-((float)(ADD_INIT+i))));
 353       }
 354 
 355     }
 356 
 357     if (errn > 0)
 358       return errn;
 359 
 360     System.out.println("Time");
 361     long start, end;
 362 
 363     start = System.currentTimeMillis();
 364     for (int i=0; i<ITERS; i++) {
 365       test_sum(a1);
 366     }
 367     end = System.currentTimeMillis();
 368     System.out.println("test_sum: " + (end - start));
 369 
 370     start = System.currentTimeMillis();
 371     for (int i=0; i<ITERS; i++) {
 372       test_addc(a0, a1);
 373     }
 374     end = System.currentTimeMillis();
 375     System.out.println("test_addc: " + (end - start));
 376     start = System.currentTimeMillis();
 377     for (int i=0; i<ITERS; i++) {
 378       test_addv(a0, a1, VALUE);
 379     }
 380     end = System.currentTimeMillis();
 381     System.out.println("test_addv: " + (end - start));
 382     start = System.currentTimeMillis();
 383     for (int i=0; i<ITERS; i++) {
 384       test_adda(a0, a1, a2);
 385     }
 386     end = System.currentTimeMillis();
 387     System.out.println("test_adda: " + (end - start));
 388 
 389     start = System.currentTimeMillis();
 390     for (int i=0; i<ITERS; i++) {
 391       test_subc(a0, a1);
 392     }
 393     end = System.currentTimeMillis();
 394     System.out.println("test_subc: " + (end - start));
 395     start = System.currentTimeMillis();
 396     for (int i=0; i<ITERS; i++) {
 397       test_subv(a0, a1, VALUE);
 398     }
 399     end = System.currentTimeMillis();
 400     System.out.println("test_subv: " + (end - start));
 401     start = System.currentTimeMillis();
 402     for (int i=0; i<ITERS; i++) {
 403       test_suba(a0, a1, a2);
 404     }
 405     end = System.currentTimeMillis();
 406     System.out.println("test_suba: " + (end - start));
 407 
 408     start = System.currentTimeMillis();
 409     for (int i=0; i<ITERS; i++) {
 410       test_mulc(a0, a1);
 411     }
 412     end = System.currentTimeMillis();
 413     System.out.println("test_mulc: " + (end - start));
 414     start = System.currentTimeMillis();
 415     for (int i=0; i<ITERS; i++) {
 416       test_mulv(a0, a1, VALUE);
 417     }
 418     end = System.currentTimeMillis();
 419     System.out.println("test_mulv: " + (end - start));
 420     start = System.currentTimeMillis();
 421     for (int i=0; i<ITERS; i++) {
 422       test_mula(a0, a1, a2);
 423     }
 424     end = System.currentTimeMillis();
 425     System.out.println("test_mula: " + (end - start));
 426 
 427     start = System.currentTimeMillis();
 428     for (int i=0; i<ITERS; i++) {
 429       test_divc(a0, a1);
 430     }
 431     end = System.currentTimeMillis();
 432     System.out.println("test_divc: " + (end - start));
 433     start = System.currentTimeMillis();
 434     for (int i=0; i<ITERS; i++) {
 435       test_divv(a0, a1, VALUE);
 436     }
 437     end = System.currentTimeMillis();
 438     System.out.println("test_divv: " + (end - start));
 439     start = System.currentTimeMillis();
 440     for (int i=0; i<ITERS; i++) {
 441       test_diva(a0, a1, a2);
 442     }
 443     end = System.currentTimeMillis();
 444     System.out.println("test_diva: " + (end - start));
 445 
 446     start = System.currentTimeMillis();
 447     for (int i=0; i<ITERS; i++) {
 448       test_mulc_n(a0, a1);
 449     }
 450     end = System.currentTimeMillis();
 451     System.out.println("test_mulc_n: " + (end - start));
 452     start = System.currentTimeMillis();
 453     for (int i=0; i<ITERS; i++) {
 454       test_mulv(a0, a1, -VALUE);
 455     }
 456     end = System.currentTimeMillis();
 457     System.out.println("test_mulv_n: " + (end - start));
 458     start = System.currentTimeMillis();
 459     for (int i=0; i<ITERS; i++) {
 460       test_mula(a0, a1, a3);
 461     }
 462     end = System.currentTimeMillis();
 463     System.out.println("test_mula_n: " + (end - start));
 464 
 465     start = System.currentTimeMillis();
 466     for (int i=0; i<ITERS; i++) {
 467       test_divc_n(a0, a1);
 468     }
 469     end = System.currentTimeMillis();
 470     System.out.println("test_divc_n: " + (end - start));
 471     start = System.currentTimeMillis();
 472     for (int i=0; i<ITERS; i++) {
 473       test_divv(a0, a1, -VALUE);
 474     }
 475     end = System.currentTimeMillis();
 476     System.out.println("test_divv_n: " + (end - start));
 477     start = System.currentTimeMillis();
 478     for (int i=0; i<ITERS; i++) {
 479       test_diva(a0, a1, a3);
 480     }
 481     end = System.currentTimeMillis();
 482     System.out.println("test_diva_n: " + (end - start));
 483 
 484     start = System.currentTimeMillis();
 485     for (int i=0; i<ITERS; i++) {
 486       test_negc(a0, a1);
 487     }
 488     end = System.currentTimeMillis();
 489     System.out.println("test_negc_n: " + (end - start));
 490 
 491     return errn;
 492   }
 493 
 494   static float test_sum(float[] a1) {
 495     float sum = 0;
 496     for (int i = 0; i < a1.length; i+=1) {
 497       sum += a1[i];
 498     }
 499     return sum;
 500   }
 501 
 502   static void test_addc(float[] a0, float[] a1) {
 503     for (int i = 0; i < a0.length; i+=1) {
 504       a0[i] = (a1[i]+VALUE);
 505     }
 506   }
 507   static void test_addv(float[] a0, float[] a1, float b) {
 508     for (int i = 0; i < a0.length; i+=1) {
 509       a0[i] = (a1[i]+b);
 510     }
 511   }
 512   static void test_adda(float[] a0, float[] a1, float[] a2) {
 513     for (int i = 0; i < a0.length; i+=1) {
 514       a0[i] = (a1[i]+a2[i]);
 515     }
 516   }
 517 
 518   static void test_subc(float[] a0, float[] a1) {
 519     for (int i = 0; i < a0.length; i+=1) {
 520       a0[i] = (a1[i]-VALUE);
 521     }
 522   }
 523   static void test_subv(float[] a0, float[] a1, float b) {
 524     for (int i = 0; i < a0.length; i+=1) {
 525       a0[i] = (a1[i]-b);
 526     }
 527   }
 528   static void test_suba(float[] a0, float[] a1, float[] a2) {
 529     for (int i = 0; i < a0.length; i+=1) {
 530       a0[i] = (a1[i]-a2[i]);
 531     }
 532   }
 533 
 534   static void test_mulc(float[] a0, float[] a1) {
 535     for (int i = 0; i < a0.length; i+=1) {
 536       a0[i] = (a1[i]*VALUE);
 537     }
 538   }
 539   static void test_mulc_n(float[] a0, float[] a1) {
 540     for (int i = 0; i < a0.length; i+=1) {
 541       a0[i] = (a1[i]*(-VALUE));
 542     }
 543   }
 544   static void test_mulv(float[] a0, float[] a1, float b) {
 545     for (int i = 0; i < a0.length; i+=1) {
 546       a0[i] = (a1[i]*b);
 547     }
 548   }
 549   static void test_mula(float[] a0, float[] a1, float[] a2) {
 550     for (int i = 0; i < a0.length; i+=1) {
 551       a0[i] = (a1[i]*a2[i]);
 552     }
 553   }
 554 
 555   static void test_divc(float[] a0, float[] a1) {
 556     for (int i = 0; i < a0.length; i+=1) {
 557       a0[i] = (a1[i]/VALUE);
 558     }
 559   }
 560   static void test_divc_n(float[] a0, float[] a1) {
 561     for (int i = 0; i < a0.length; i+=1) {
 562       a0[i] = (a1[i]/(-VALUE));
 563     }
 564   }
 565   static void test_divv(float[] a0, float[] a1, float b) {
 566     for (int i = 0; i < a0.length; i+=1) {
 567       a0[i] = (a1[i]/b);
 568     }
 569   }
 570   static void test_diva(float[] a0, float[] a1, float[] a2) {
 571     for (int i = 0; i < a0.length; i+=1) {
 572       a0[i] = (a1[i]/a2[i]);
 573     }
 574   }
 575 
 576   static void test_negc(float[] a0, float[] a1) {
 577     for (int i = 0; i < a0.length; i+=1) {
 578       a0[i] = (float)(-((float)a1[i]));
 579     }
 580   }
 581 
 582   static int verify(String text, int i, float elem, float val) {
 583     if (elem != val && !(Float.isNaN(elem) && Float.isNaN(val))) {
 584       System.err.println(text + "[" + i + "] = " + elem + " != " + val);
 585       return 1;
 586     }
 587     return 0;
 588   }
 589 }
--- EOF ---