< prev index next >

test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/FloatScalar.java

Print this page
rev 55894 : 8222897: [vector] Renaming of shift, rotate operations. Few other api changes.
Summary: Renaming of shift, rotate operations. Few other api changes.
Reviewed-by: jrose, briangoetz


 243 
 244 
 245 
 246 
 247 
 248 
 249 
 250 
 251 
 252 
 253 
 254 
 255 
 256 
 257 
 258 
 259 
 260 
 261 
 262 












 263     @Benchmark
 264     public void max(Blackhole bh) {
 265         float[] as = fa.apply(size);
 266         float[] bs = fb.apply(size);
 267         float[] rs = fr.apply(size);
 268 
 269         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 270             for (int i = 0; i < as.length; i++) {
 271                 float a = as[i];
 272                 float b = bs[i];
 273                 rs[i] = (float)(Math.max(a, b));
 274             }
 275         }
 276 
 277         bh.consume(rs);
 278     }
 279 
 280     @Benchmark
 281     public void min(Blackhole bh) {
 282         float[] as = fa.apply(size);
 283         float[] bs = fb.apply(size);
 284         float[] rs = fr.apply(size);
 285 
 286         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 287             for (int i = 0; i < as.length; i++) {
 288                 float a = as[i];
 289                 float b = bs[i];
 290                 rs[i] = (float)(Math.min(a, b));
 291             }
 292         }
 293 
 294         bh.consume(rs);
 295     }
 296 
 297 
 298 
 299 
 300     @Benchmark
 301     public void addAll(Blackhole bh) {
 302         float[] as = fa.apply(size);
 303         float r = 0;
 304         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 305             r = 0;
 306             for (int i = 0; i < as.length; i++) {
 307                 r += as[i];
 308             }
 309         }
 310         bh.consume(r);
 311     }
 312 
 313     @Benchmark
 314     public void mulAll(Blackhole bh) {
 315         float[] as = fa.apply(size);
 316         float r = 1;
 317         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 318             r = 1;
 319             for (int i = 0; i < as.length; i++) {
 320                 r *= as[i];
 321             }
 322         }
 323         bh.consume(r);
 324     }
 325 
 326     @Benchmark
 327     public void minAll(Blackhole bh) {
 328         float[] as = fa.apply(size);
 329         float r = Float.POSITIVE_INFINITY;
 330         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 331             r = Float.POSITIVE_INFINITY;
 332             for (int i = 0; i < as.length; i++) {
 333                 r = (float)Math.min(r, as[i]);
 334             }
 335         }
 336         bh.consume(r);
 337     }
 338 
 339     @Benchmark
 340     public void maxAll(Blackhole bh) {
 341         float[] as = fa.apply(size);
 342         float r = Float.NEGATIVE_INFINITY;
 343         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 344             r = Float.NEGATIVE_INFINITY;
 345             for (int i = 0; i < as.length; i++) {
 346                 r = (float)Math.max(r, as[i]);
 347             }
 348         }
 349         bh.consume(r);
 350     }
 351 
 352 
 353 
 354     @Benchmark
 355     public void lessThan(Blackhole bh) {
 356         float[] as = fa.apply(size);
 357         float[] bs = fb.apply(size);
 358 
 359         boolean r = false;
 360         for (int ic = 0; ic < INVOC_COUNT; ic++) {




 243 
 244 
 245 
 246 
 247 
 248 
 249 
 250 
 251 
 252 
 253 
 254 
 255 
 256 
 257 
 258 
 259 
 260 
 261 
 262 
 263 
 264 
 265 
 266 
 267 
 268 
 269 
 270 
 271 
 272 
 273 
 274 
 275     @Benchmark
 276     public void max(Blackhole bh) {
 277         float[] as = fa.apply(size);
 278         float[] bs = fb.apply(size);
 279         float[] rs = fr.apply(size);
 280 
 281         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 282             for (int i = 0; i < as.length; i++) {
 283                 float a = as[i];
 284                 float b = bs[i];
 285                 rs[i] = (float)(Math.max(a, b));
 286             }
 287         }
 288 
 289         bh.consume(rs);
 290     }
 291 
 292     @Benchmark
 293     public void min(Blackhole bh) {
 294         float[] as = fa.apply(size);
 295         float[] bs = fb.apply(size);
 296         float[] rs = fr.apply(size);
 297 
 298         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 299             for (int i = 0; i < as.length; i++) {
 300                 float a = as[i];
 301                 float b = bs[i];
 302                 rs[i] = (float)(Math.min(a, b));
 303             }
 304         }
 305 
 306         bh.consume(rs);
 307     }
 308 
 309 
 310 
 311 
 312     @Benchmark
 313     public void addLanes(Blackhole bh) {
 314         float[] as = fa.apply(size);
 315         float r = 0;
 316         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 317             r = 0;
 318             for (int i = 0; i < as.length; i++) {
 319                 r += as[i];
 320             }
 321         }
 322         bh.consume(r);
 323     }
 324 
 325     @Benchmark
 326     public void mulLanes(Blackhole bh) {
 327         float[] as = fa.apply(size);
 328         float r = 1;
 329         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 330             r = 1;
 331             for (int i = 0; i < as.length; i++) {
 332                 r *= as[i];
 333             }
 334         }
 335         bh.consume(r);
 336     }
 337 
 338     @Benchmark
 339     public void minLanes(Blackhole bh) {
 340         float[] as = fa.apply(size);
 341         float r = Float.POSITIVE_INFINITY;
 342         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 343             r = Float.POSITIVE_INFINITY;
 344             for (int i = 0; i < as.length; i++) {
 345                 r = (float)Math.min(r, as[i]);
 346             }
 347         }
 348         bh.consume(r);
 349     }
 350 
 351     @Benchmark
 352     public void maxLanes(Blackhole bh) {
 353         float[] as = fa.apply(size);
 354         float r = Float.NEGATIVE_INFINITY;
 355         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 356             r = Float.NEGATIVE_INFINITY;
 357             for (int i = 0; i < as.length; i++) {
 358                 r = (float)Math.max(r, as[i]);
 359             }
 360         }
 361         bh.consume(r);
 362     }
 363 
 364 
 365 
 366     @Benchmark
 367     public void lessThan(Blackhole bh) {
 368         float[] as = fa.apply(size);
 369         float[] bs = fb.apply(size);
 370 
 371         boolean r = false;
 372         for (int ic = 0; ic < INVOC_COUNT; ic++) {


< prev index next >