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