test/hotspot/jtreg/compiler/loopopts/LoopUnswitchingBadNodeBudget.java
changeset 55150 ba171f871932
child 57803 23e3ab980622
equal deleted inserted replaced
55149:00f7fce88e25 55150:ba171f871932
       
     1 /*
       
     2  * Copyright (c) 2019, 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 8223502
       
    27  * @summary Node estimate for loop unswitching is not correct:
       
    28  *          assert(delta <= 2 * required) failed: Bad node estimate
       
    29  *
       
    30  * @requires !vm.graal.enabled
       
    31  *
       
    32  * @run main/othervm -XX:-TieredCompilation -XX:-BackgroundCompilation
       
    33  *      -XX:-UseOnStackReplacement -XX:CompileOnly=LoopUnswitchingBadNodeBudget::test
       
    34  *      -XX:CompileCommand=dontinline,LoopUnswitchingBadNodeBudget::helper
       
    35  *      -XX:+UnlockExperimentalVMOptions -XX:-UseSwitchProfiling LoopUnswitchingBadNodeBudget
       
    36  *
       
    37  */
       
    38 
       
    39 public class LoopUnswitchingBadNodeBudget {
       
    40 
       
    41     public static void main(String[] args) {
       
    42         for (int i = 0; i < 20_000; i++) {
       
    43             for (int j = 0; j < 100; j++) {
       
    44                 test(j, true, 0, 0, 0);
       
    45                 test(j, false, 0, 0, 0);
       
    46             }
       
    47         }
       
    48     }
       
    49 
       
    50     private static int test(int j, boolean flag, int k, int l, int m) {
       
    51         int res = 0;
       
    52         for (int i = 0; i < 24; i++) {
       
    53             if (flag) {
       
    54                 k = k / 2;
       
    55                 l = l * 2;
       
    56                 m = m + 2;
       
    57             }
       
    58             switch (j) {
       
    59                 case  0: break;
       
    60                 case  1: return helper(j, k, l, m);
       
    61                 case  2: return helper(j, k, l, m);
       
    62                 case  3: return helper(j, k, l, m);
       
    63                 case  4: return helper(j, k, l, m);
       
    64                 case  5: return helper(j, k, l, m);
       
    65                 case  6: return helper(j, k, l, m);
       
    66                 case  7: return helper(j, k, l, m);
       
    67                 case  8: return helper(j, k, l, m);
       
    68                 case  9: return helper(j, k, l, m);
       
    69                 case 10: return helper(j, k, l, m);
       
    70                 case 11: return helper(j, k, l, m);
       
    71                 case 12: return helper(j, k, l, m);
       
    72                 case 13: return helper(j, k, l, m);
       
    73                 case 14: return helper(j, k, l, m);
       
    74                 case 15: return helper(j, k, l, m);
       
    75                 case 16: return helper(j, k, l, m);
       
    76                 case 17: return helper(j, k, l, m);
       
    77                 case 18: return helper(j, k, l, m);
       
    78                 case 19: return helper(j, k, l, m);
       
    79                 case 20: return helper(j, k, l, m);
       
    80                 case 21: return helper(j, k, l, m);
       
    81                 case 22: return helper(j, k, l, m);
       
    82                 case 23: return helper(j, k, l, m);
       
    83                 case 24: return helper(j, k, l, m);
       
    84                 case 25: return helper(j, k, l, m);
       
    85                 case 26: return helper(j, k, l, m);
       
    86                 case 27: return helper(j, k, l, m);
       
    87                 case 28: return helper(j, k, l, m);
       
    88                 case 29: return helper(j, k, l, m);
       
    89                 case 30: return helper(j, k, l, m);
       
    90                 case 31: return helper(j, k, l, m);
       
    91                 case 32: return helper(j, k, l, m);
       
    92                 case 33: return helper(j, k, l, m);
       
    93                 case 34: return helper(j, k, l, m);
       
    94                 case 35: return helper(j, k, l, m);
       
    95                 case 36: return helper(j, k, l, m);
       
    96                 case 37: return helper(j, k, l, m);
       
    97                 case 38: return helper(j, k, l, m);
       
    98                 case 39: return helper(j, k, l, m);
       
    99                 case 40: return helper(j, k, l, m);
       
   100                 case 41: return helper(j, k, l, m);
       
   101                 case 42: return helper(j, k, l, m);
       
   102                 case 43: return helper(j, k, l, m);
       
   103                 case 44: return helper(j, k, l, m);
       
   104                 case 45: return helper(j, k, l, m);
       
   105                 case 46: return helper(j, k, l, m);
       
   106                 case 47: return helper(j, k, l, m);
       
   107                 case 48: return helper(j, k, l, m);
       
   108                 case 49: return helper(j, k, l, m);
       
   109                 case 50: return helper(j, k, l, m);
       
   110                 case 51: return helper(j, k, l, m);
       
   111                 case 52: return helper(j, k, l, m);
       
   112                 case 53: return helper(j, k, l, m);
       
   113                 case 54: return helper(j, k, l, m);
       
   114                 case 55: return helper(j, k, l, m);
       
   115                 case 56: return helper(j, k, l, m);
       
   116                 case 57: return helper(j, k, l, m);
       
   117                 case 58: return helper(j, k, l, m);
       
   118                 case 59: return helper(j, k, l, m);
       
   119                 case 60: return helper(j, k, l, m);
       
   120                 case 61: return helper(j, k, l, m);
       
   121                 case 62: return helper(j, k, l, m);
       
   122                 case 63: return helper(j, k, l, m);
       
   123                 case 64: return helper(j, k, l, m);
       
   124                 case 65: return helper(j, k, l, m);
       
   125                 case 66: return helper(j, k, l, m);
       
   126                 case 67: return helper(j, k, l, m);
       
   127                 case 68: return helper(j, k, l, m);
       
   128                 case 69: return helper(j, k, l, m);
       
   129                 case 70: return helper(j, k, l, m);
       
   130                 case 71: return helper(j, k, l, m);
       
   131                 case 72: return helper(j, k, l, m);
       
   132                 case 73: return helper(j, k, l, m);
       
   133                 case 74: return helper(j, k, l, m);
       
   134                 case 75: return helper(j, k, l, m);
       
   135                 case 76: return helper(j, k, l, m);
       
   136                 case 77: return helper(j, k, l, m);
       
   137                 case 78: return helper(j, k, l, m);
       
   138                 case 79: return helper(j, k, l, m);
       
   139                 case 80: return helper(j, k, l, m);
       
   140                 case 81: return helper(j, k, l, m);
       
   141                 case 82: return helper(j, k, l, m);
       
   142                 case 83: return helper(j, k, l, m);
       
   143                 case 84: return helper(j, k, l, m);
       
   144                 case 85: return helper(j, k, l, m);
       
   145                 case 86: return helper(j, k, l, m);
       
   146                 case 87: return helper(j, k, l, m);
       
   147                 case 88: return helper(j, k, l, m);
       
   148                 case 89: return helper(j, k, l, m);
       
   149                 case 90: return helper(j, k, l, m);
       
   150                 case 91: return helper(j, k, l, m);
       
   151                 case 92: return helper(j, k, l, m);
       
   152                 case 93: return helper(j, k, l, m);
       
   153                 case 94: return helper(j, k, l, m);
       
   154                 case 95: return helper(j, k, l, m);
       
   155                 case 96: return helper(j, k, l, m);
       
   156                 case 97: return helper(j, k, l, m);
       
   157                 case 98: return helper(j, k, l, m);
       
   158                 case 99: return helper(j, k, l, m);
       
   159             }
       
   160             res += helper(j, k, l, m);
       
   161         }
       
   162         return res;
       
   163     }
       
   164 
       
   165     private static int helper(int j, int k, int l, int m) {
       
   166         return j + k;
       
   167     }
       
   168 }