alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Java example source code file (TestDoubleBoxing.java)

This example Java source code file (TestDoubleBoxing.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

double, internalerror, string, testdoubleboxing

The TestDoubleBoxing.java Java example source code

/*
 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug 6934604
 * @summary enable parts of EliminateAutoBox by default
 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestDoubleBoxing
 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
 * -XX:CompileCommand=exclude,TestDoubleBoxing.dummy -XX:CompileCommand=exclude,TestDoubleBoxing.foo -XX:CompileCommand=exclude,TestDoubleBoxing.foob TestDoubleBoxing
 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
 * -XX:CompileCommand=exclude,TestDoubleBoxing.dummy -XX:CompileCommand=exclude,TestDoubleBoxing.foo -XX:CompileCommand=exclude,TestDoubleBoxing.foob TestDoubleBoxing
 *
 */

public class TestDoubleBoxing {

  static final Double ibc = new Double(1.);

  //===============================================
  // Non-inlined methods to test deoptimization info
  static void   dummy()        { }
  static double foo(double i)  { return i; }
  static Double foob(double i) { return Double.valueOf(i); }


  static double simple(double i) {
    Double ib = new Double(i);
    return ib;
  }

  static double simpleb(double i) {
    Double ib = Double.valueOf(i);
    return ib;
  }

  static double simplec() {
    Double ib = ibc;
    return ib;
  }

  static double simplef(double i) {
    Double ib = foob(i);
    return ib;
  }

  static double simplep(Double ib) {
    return ib;
  }

  static double simple2(double i) {
    Double ib1 = new Double(i);
    Double ib2 = new Double(i+1.);
    return ib1 + ib2;
  }

  static double simpleb2(double i) {
    Double ib1 = Double.valueOf(i);
    Double ib2 = Double.valueOf(i+1.);
    return ib1 + ib2;
  }

  static double simplem2(double i) {
    Double ib1 = new Double(i);
    Double ib2 = Double.valueOf(i+1.);
    return ib1 + ib2;
  }

  static double simplep2(double i, Double ib1) {
    Double ib2 = Double.valueOf(i+1.);
    return ib1 + ib2;
  }

  static double simplec2(double i) {
    Double ib1 = ibc;
    Double ib2 = Double.valueOf(i+1.);
    return ib1 + ib2;
  }

  //===============================================
  static double test(double f, int i) {
    Double ib = new Double(f);
    if ((i&1) == 0)
      ib = f+1.;
    return ib;
  }

  static double testb(double f, int i) {
    Double ib = f;
    if ((i&1) == 0)
      ib = (f+1.);
    return ib;
  }

  static double testm(double f, int i) {
    Double ib = f;
    if ((i&1) == 0)
      ib = new Double(f+1.);
    return ib;
  }

  static double testp(double f, int i, Double ib) {
    if ((i&1) == 0)
      ib = new Double(f+1.);
    return ib;
  }

  static double testc(double f, int i) {
    Double ib = ibc;
    if ((i&1) == 0)
      ib = new Double(f+1.);
    return ib;
  }

  static double test2(double f, int i) {
    Double ib1 = new Double(f);
    Double ib2 = new Double(f+1.);
    if ((i&1) == 0) {
      ib1 = new Double(f+1.);
      ib2 = new Double(f+2.);
    }
    return ib1+ib2;
  }

  static double testb2(double f, int i) {
    Double ib1 = f;
    Double ib2 = f+1.;
    if ((i&1) == 0) {
      ib1 = (f+1.);
      ib2 = (f+2.);
    }
    return ib1+ib2;
  }

  static double testm2(double f, int i) {
    Double ib1 = new Double(f);
    Double ib2 = f+1.;
    if ((i&1) == 0) {
      ib1 = new Double(f+1.);
      ib2 = (f+2.);
    }
    return ib1+ib2;
  }

  static double testp2(double f, int i, Double ib1) {
    Double ib2 = f+1.;
    if ((i&1) == 0) {
      ib1 = new Double(f+1.);
      ib2 = (f+2.);
    }
    return ib1+ib2;
  }

  static double testc2(double f, int i) {
    Double ib1 = ibc;
    Double ib2 = f+1.;
    if ((i&1) == 0) {
      ib1 = (ibc+1.);
      ib2 = (f+2.);
    }
    return ib1+ib2;
  }

  //===============================================
  static double sum(double[] a) {
    double result = 1.;
    for (Double i : a)
        result += i;
    return result;
  }

  static double sumb(double[] a) {
    Double result = 1.;
    for (Double i : a)
        result += i;
    return result;
  }

  static double sumc(double[] a) {
    Double result = ibc;
    for (Double i : a)
        result += i;
    return result;
  }

  static double sumf(double[] a) {
    Double result = foob(1.);
    for (Double i : a)
        result += i;
    return result;
  }

  static double sump(double[] a, Double result) {
    for (Double i : a)
        result += i;
    return result;
  }

  static double sum2(double[] a) {
    double result1 = 1.;
    double result2 = 1.;
    for (Double i : a) {
        result1 += i;
        result2 += i + 1.;
    }
    return result1 + result2;
  }

  static double sumb2(double[] a) {
    Double result1 = 1.;
    Double result2 = 1.;
    for (Double i : a) {
        result1 += i;
        result2 += i + 1.;
    }
    return result1 + result2;
  }

  static double summ2(double[] a) {
    Double result1 = 1.;
    Double result2 = new Double(1.);
    for (Double i : a) {
        result1 += i;
        result2 += new Double(i + 1.);
    }
    return result1 + result2;
  }

  static double sump2(double[] a, Double result2) {
    Double result1 = 1.;
    for (Double i : a) {
        result1 += i;
        result2 += i + 1.;
    }
    return result1 + result2;
  }

  static double sumc2(double[] a) {
    Double result1 = 1.;
    Double result2 = ibc;
    for (Double i : a) {
        result1 += i;
        result2 += i + ibc;
    }
    return result1 + result2;
  }

  //===============================================
  static double remi_sum() {
    Double j = new Double(1.);
    for (int i = 0; i< 1000; i++) {
      j = new Double(j + 1.);
    }
    return j;
  }

  static double remi_sumb() {
    Double j = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      j = j + 1.;
    }
    return j;
  }

  static double remi_sumf() {
    Double j = foob(1.);
    for (int i = 0; i< 1000; i++) {
      j = j + 1.;
    }
    return j;
  }

  static double remi_sump(Double j) {
    for (int i = 0; i< 1000; i++) {
      j = new Double(j + 1.);
    }
    return j;
  }

  static double remi_sumc() {
    Double j = ibc;
    for (int i = 0; i< 1000; i++) {
      j = j + ibc;
    }
    return j;
  }

  static double remi_sum2() {
    Double j1 = new Double(1.);
    Double j2 = new Double(1.);
    for (int i = 0; i< 1000; i++) {
      j1 = new Double(j1 + 1.);
      j2 = new Double(j2 + 2.);
    }
    return j1 + j2;
  }

  static double remi_sumb2() {
    Double j1 = Double.valueOf(1.);
    Double j2 = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      j1 = j1 + 1.;
      j2 = j2 + 2.;
    }
    return j1 + j2;
  }

  static double remi_summ2() {
    Double j1 = new Double(1.);
    Double j2 = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      j1 = new Double(j1 + 1.);
      j2 = j2 + 2.;
    }
    return j1 + j2;
  }

  static double remi_sump2(Double j1) {
    Double j2 = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      j1 = new Double(j1 + 1.);
      j2 = j2 + 2.;
    }
    return j1 + j2;
  }

  static double remi_sumc2() {
    Double j1 = ibc;
    Double j2 = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      j1 = j1 + ibc;
      j2 = j2 + 2.;
    }
    return j1 + j2;
  }


  //===============================================
  // Safepointa and debug info for deoptimization
  static double simple_deop(double i) {
    Double ib = new Double(foo(i));
    dummy();
    return ib;
  }

  static double simpleb_deop(double i) {
    Double ib = Double.valueOf(foo(i));
    dummy();
    return ib;
  }

  static double simplef_deop(double i) {
    Double ib = foob(i);
    dummy();
    return ib;
  }

  static double simplep_deop(Double ib) {
    dummy();
    return ib;
  }

  static double simplec_deop(double i) {
    Double ib = ibc;
    dummy();
    return ib;
  }

  static double test_deop(double f, int i) {
    Double ib = new Double(foo(f));
    if ((i&1) == 0)
      ib = foo(f+1.);
    dummy();
    return ib;
  }

  static double testb_deop(double f, int i) {
    Double ib = foo(f);
    if ((i&1) == 0)
      ib = foo(f+1.);
    dummy();
    return ib;
  }

  static double testf_deop(double f, int i) {
    Double ib = foob(f);
    if ((i&1) == 0)
      ib = foo(f+1.);
    dummy();
    return ib;
  }

  static double testp_deop(double f, int i, Double ib) {
    if ((i&1) == 0)
      ib = foo(f+1.);
    dummy();
    return ib;
  }

  static double testc_deop(double f, int i) {
    Double ib = ibc;
    if ((i&1) == 0)
      ib = foo(f+1.);
    dummy();
    return ib;
  }

  static double sum_deop(double[] a) {
    double result = 1.;
    for (Double i : a)
        result += foo(i);
    dummy();
    return result;
  }

  static double sumb_deop(double[] a) {
    Double result = 1.;
    for (Double i : a)
        result += foo(i);
    dummy();
    return result;
  }

  static double sumf_deop(double[] a) {
    Double result = 1.;
    for (Double i : a)
        result += foob(i);
    dummy();
    return result;
  }

  static double sump_deop(double[] a, Double result) {
    for (Double i : a)
        result += foob(i);
    dummy();
    return result;
  }

  static double sumc_deop(double[] a) {
    Double result = ibc;
    for (Double i : a)
        result += foo(i);
    dummy();
    return result;
  }

  static double remi_sum_deop() {
    Double j = new Double(foo(1.));
    for (int i = 0; i< 1000; i++) {
      j = new Double(foo(j + 1.));
    }
    dummy();
    return j;
  }

  static double remi_sumb_deop() {
    Double j = Double.valueOf(foo(1.));
    for (int i = 0; i< 1000; i++) {
      j = foo(j + 1.);
    }
    dummy();
    return j;
  }

  static double remi_sumf_deop() {
    Double j = foob(1.);
    for (int i = 0; i< 1000; i++) {
      j = foo(j + 1.);
    }
    dummy();
    return j;
  }

  static double remi_sump_deop(Double j) {
    for (int i = 0; i< 1000; i++) {
      j = foo(j + 1.);
    }
    dummy();
    return j;
  }

  static double remi_sumc_deop() {
    Double j = ibc;
    for (int i = 0; i< 1000; i++) {
      j = foo(j + 1.);
    }
    dummy();
    return j;
  }

  //===============================================
  // Conditional increment
  static double remi_sum_cond() {
    Double j = new Double(1.);
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j = new Double(j + 1.);
      }
    }
    return j;
  }

  static double remi_sumb_cond() {
    Double j = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j = j + 1.;
      }
    }
    return j;
  }

  static double remi_sumf_cond() {
    Double j = foob(1.);
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j = j + 1.;
      }
    }
    return j;
  }

  static double remi_sump_cond(Double j) {
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j = j + 1.;
      }
    }
    return j;
  }

  static double remi_sumc_cond() {
    Double j = ibc;
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j = j + ibc;
      }
    }
    return j;
  }

  static double remi_sum2_cond() {
    Double j1 = new Double(1.);
    Double j2 = new Double(1.);
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j1 = new Double(j1 + 1.);
      } else {
        j2 = new Double(j2 + 2.);
      }
    }
    return j1 + j2;
  }

  static double remi_sumb2_cond() {
    Double j1 = Double.valueOf(1.);
    Double j2 = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j1 = j1 + 1.;
      } else {
        j2 = j2 + 2.;
      }
    }
    return j1 + j2;
  }

  static double remi_summ2_cond() {
    Double j1 = new Double(1.);
    Double j2 = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j1 = new Double(j1 + 1.);
      } else {
        j2 = j2 + 2.;
      }
    }
    return j1 + j2;
  }

  static double remi_sump2_cond(Double j1) {
    Double j2 = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j1 = new Double(j1 + 1.);
      } else {
        j2 = j2 + 2.;
      }
    }
    return j1 + j2;
  }

  static double remi_sumc2_cond() {
    Double j1 = ibc;
    Double j2 = Double.valueOf(1.);
    for (int i = 0; i< 1000; i++) {
      if ((i&1) == 0) {
        j1 = j1 + ibc;
      } else {
        j2 = j2 + 2;
      }
    }
    return j1 + j2;
  }


  public static void main(String[] args) {
    final int ntests = 70;

    String[] test_name = new String[] {
        "simple",      "simpleb",      "simplec",      "simplef",      "simplep",
        "simple2",     "simpleb2",     "simplec2",     "simplem2",     "simplep2",
        "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
        "test",        "testb",        "testc",        "testm",        "testp",
        "test2",       "testb2",       "testc2",       "testm2",       "testp2",
        "test_deop",   "testb_deop",   "testc_deop",   "testf_deop",   "testp_deop",
        "sum",         "sumb",         "sumc",         "sumf",         "sump",
        "sum2",        "sumb2",        "sumc2",        "summ2",        "sump2",
        "sum_deop",    "sumb_deop",    "sumc_deop",    "sumf_deop",    "sump_deop",
        "remi_sum",       "remi_sumb",       "remi_sumc",       "remi_sumf",       "remi_sump",
        "remi_sum2",      "remi_sumb2",      "remi_sumc2",      "remi_summ2",      "remi_sump2",
        "remi_sum_deop",  "remi_sumb_deop",  "remi_sumc_deop",  "remi_sumf_deop",  "remi_sump_deop",
        "remi_sum_cond",  "remi_sumb_cond",  "remi_sumc_cond",  "remi_sumf_cond",  "remi_sump_cond",
        "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
    };

    final double[] val = new double[] {
       71994000.,  71994000.,    12000.,  71994000.,  71994000.,
      144000000., 144000000., 72018000., 144000000., 144000000.,
       71994000.,  71994000.,    12000.,  71994000.,  71994000.,
       72000000.,  72000000., 36006000.,  72000000.,  72000000.,
      144012000., 144012000., 72030000., 144012000., 144012000.,
       72000000.,  72000000., 36006000.,  72000000.,  72000000.,
         499501.,    499501.,   499501.,    499501.,    499501.,
        1000002.,   1000002.,  1000002.,   1000002.,   1000002.,
         499501.,    499501.,   499501.,    499501.,    499501.,
           1001.,      1001.,     1001.,      1001.,      1001.,
           3002.,      3002.,     3002.,      3002.,      3002.,
           1001.,      1001.,     1001.,      1001.,      1001.,
            501.,       501.,      501.,       501.,       501.,
           1502.,      1502.,     1502.,      1502.,      1502.
    };

    double[] res = new double[ntests];
    for (int i = 0; i < ntests; i++) {
      res[i] = 0.;
    }


    for (int i = 0; i < 12000; i++) {
      res[0] += simple(i);
      res[1] += simpleb(i);
      res[2] += simplec();
      res[3] += simplef(i);
      res[4] += simplep((double)i);

      res[5] += simple2((double)i);
      res[6] += simpleb2((double)i);
      res[7] += simplec2((double)i);
      res[8] += simplem2((double)i);
      res[9] += simplep2((double)i, (double)i);

      res[10] += simple_deop((double)i);
      res[11] += simpleb_deop((double)i);
      res[12] += simplec_deop((double)i);
      res[13] += simplef_deop((double)i);
      res[14] += simplep_deop((double)i);

      res[15] += test((double)i, i);
      res[16] += testb((double)i, i);
      res[17] += testc((double)i, i);
      res[18] += testm((double)i, i);
      res[19] += testp((double)i, i, (double)i);

      res[20] += test2((double)i, i);
      res[21] += testb2((double)i, i);
      res[22] += testc2((double)i, i);
      res[23] += testm2((double)i, i);
      res[24] += testp2((double)i, i, (double)i);

      res[25] += test_deop((double)i, i);
      res[26] += testb_deop((double)i, i);
      res[27] += testc_deop((double)i, i);
      res[28] += testf_deop((double)i, i);
      res[29] += testp_deop((double)i, i, (double)i);
    }

    double[] ia = new double[1000];
    for (int i = 0; i < 1000; i++) {
      ia[i] = i;
    }

    for (int i = 0; i < 100; i++) {
      res[30] = sum(ia);
      res[31] = sumb(ia);
      res[32] = sumc(ia);
      res[33] = sumf(ia);
      res[34] = sump(ia, 1.);

      res[35] = sum2(ia);
      res[36] = sumb2(ia);
      res[37] = sumc2(ia);
      res[38] = summ2(ia);
      res[39] = sump2(ia, 1.);

      res[40] = sum_deop(ia);
      res[41] = sumb_deop(ia);
      res[42] = sumc_deop(ia);
      res[43] = sumf_deop(ia);
      res[44] = sump_deop(ia, 1.);

      res[45] = remi_sum();
      res[46] = remi_sumb();
      res[47] = remi_sumc();
      res[48] = remi_sumf();
      res[49] = remi_sump(1.);

      res[50] = remi_sum2();
      res[51] = remi_sumb2();
      res[52] = remi_sumc2();
      res[53] = remi_summ2();
      res[54] = remi_sump2(1.);

      res[55] = remi_sum_deop();
      res[56] = remi_sumb_deop();
      res[57] = remi_sumc_deop();
      res[58] = remi_sumf_deop();
      res[59] = remi_sump_deop(1.);

      res[60] = remi_sum_cond();
      res[61] = remi_sumb_cond();
      res[62] = remi_sumc_cond();
      res[63] = remi_sumf_cond();
      res[64] = remi_sump_cond(1.);

      res[65] = remi_sum2_cond();
      res[66] = remi_sumb2_cond();
      res[67] = remi_sumc2_cond();
      res[68] = remi_summ2_cond();
      res[69] = remi_sump2_cond(1.);
    }

    int failed = 0;
    for (int i = 0; i < ntests; i++) {
      if (res[i] != val[i]) {
        System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
        failed++;
      }
    }
    if (failed > 0) {
      System.err.println("Failed " + failed + " tests.");
      throw new InternalError();
    } else {
      System.out.println("Passed.");
    }
  }
}

Other Java examples (source code examples)

Here is a short list of links related to this Java TestDoubleBoxing.java source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.