示例#1
0
  /**
   * Logic to select the appropriate guarding mechanism for the edge from caller to callee according
   * to the controlling {@link OPT_Options}. If we are using IG_CODE_PATCH, then this method also
   * records the required dependency. Precondition: lock on {@link VM_Class#OptCLDepManager} is
   * held.
   *
   * @param caller The caller method
   * @param callee The callee method
   * @param codePatchSupported Can we use code patching at this call site?
   */
  private byte chooseGuard(
      VM_Method caller,
      VM_Method singleImpl,
      VM_Method callee,
      OPT_CompilationState state,
      boolean codePatchSupported) {
    byte guard = state.getOptions().INLINING_GUARD;
    if (codePatchSupported) {
      if (VM.VerifyAssertions && VM.runningVM) {
        VM._assert(VM_Lock.owns(VM_Class.OptCLDepManager));
      }
      if (guard == OPT_Options.IG_CODE_PATCH) {
        if (OPT_ClassLoadingDependencyManager.TRACE || OPT_ClassLoadingDependencyManager.DEBUG) {
          VM_Class.OptCLDepManager.report(
              "CODE PATCH: Inlined " + singleImpl + " into " + caller + "\n");
        }
        VM_Class.OptCLDepManager.addNotOverriddenDependency(callee, state.getCompiledMethod());
      }
    } else if (guard == OPT_Options.IG_CODE_PATCH) {
      guard = OPT_Options.IG_METHOD_TEST;
    }

    if (guard == OPT_Options.IG_METHOD_TEST && singleImpl.getDeclaringClass().isFinal()) {
      // class test is more efficient and just as effective
      guard = OPT_Options.IG_CLASS_TEST;
    }
    return guard;
  }
示例#2
0
  /**
   * Should we inline a particular call site?
   *
   * @param state information needed to make the inlining decision
   * @return an OPT_InlineDecision with the result
   */
  public OPT_InlineDecision shouldInline(final OPT_CompilationState state) {
    final OPT_Options opts = state.getOptions();
    final boolean verbose = opts.PRINT_DETAILED_INLINE_REPORT;
    if (!opts.INLINE) {
      return OPT_InlineDecision.NO("inlining not enabled");
    }

    final VM_Method staticCallee = state.obtainTarget();
    final VM_NormalMethod rootMethod = state.getRootMethod();
    final VM_Method caller = state.getMethod();
    final int bcIndex = state.getBytecodeIndex();

    if (verbose)
      VM.sysWriteln(
          "Begin inline decision for " + "<" + caller + "," + bcIndex + "," + staticCallee + ">");

    // Stage 1: At all optimization levels we should attempt to inline
    //          trivial methods. Even if the inline code is never executed,
    //          inlining a trivial method is a no cost operation as the impact
    //          on code size should be negligible and compile time usually is
    //          reduced since we expect to eliminate the call instruction (or
    //          at worse replace one call instruction with another one).
    if (!state.isInvokeInterface()) {
      if (staticCallee.isNative()) {
        if (verbose) VM.sysWriteln("\tNO: native method\n");
        return OPT_InlineDecision.NO("native method");
      }
      if (hasNoInlinePragma(staticCallee, state)) {
        if (verbose) VM.sysWriteln("\tNO: pragmaNoInline\n");
        return OPT_InlineDecision.NO("pragmaNoInline");
      }
      if (!staticCallee.isAbstract()) {
        int inlinedSizeEstimate = inlinedSizeEstimate((VM_NormalMethod) staticCallee, state);
        boolean guardless = state.getHasPreciseTarget() || !needsGuard(staticCallee);
        if (inlinedSizeEstimate < opts.IC_MAX_ALWAYS_INLINE_TARGET_SIZE
            && guardless
            && !state.getSequence().containsMethod(staticCallee)) {
          if (verbose) VM.sysWriteln("\tYES: trivial guardless inline\n");
          return OPT_InlineDecision.YES(staticCallee, "trivial inline");
        }
      }
    }

    if (opts.getOptLevel() == 0) {
      // at opt level 0, trivial unguarded inlines are the only kind we consider
      if (verbose) VM.sysWriteln("\tNO: only do trivial inlines at O0\n");
      return OPT_InlineDecision.NO("Only do trivial inlines at O0");
    }

    if (rootMethod.inlinedSizeEstimate() > opts.IC_MASSIVE_METHOD_SIZE) {
      // In massive methods, we do not do any additional inlining to
      // avoid completely blowing out compile time by making a bad situation worse
      if (verbose) VM.sysWriteln("\tNO: only do trivial inlines into massive methods\n");
      return OPT_InlineDecision.NO("Root method is massive; no non-trivial inlines");
    }

    // Stage 2: Determine based on profile data and static information
    //          what are the possible targets of this call.
    //
    VM_WeightedCallTargets targets = null;
    boolean purelyStatic = true;
    if (VM_Controller.dcg != null && VM_Controller.options.ADAPTIVE_INLINING) {
      targets = VM_Controller.dcg.getCallTargets(caller, bcIndex);
      if (targets != null) {
        if (verbose) VM.sysWriteln("\tFound profile data");
        purelyStatic = false;
        if (state.getHasPreciseTarget()) {
          // static analysis tells us that there is only one possible target.
          // Filter the profile information accordingly.
          targets = targets.filter(staticCallee);
          if (verbose) VM.sysWriteln("\tFiltered to match precise target");
          if (targets == null) {
            if (verbose) VM.sysWriteln("\tNow no profile data...");
            // After filtering, no matching profile data, fall back to
            // static information to avoid degradations
            targets = VM_WeightedCallTargets.create(staticCallee, 0);
            purelyStatic = true;
          }
        }
      }
    }

    // Critical section: must prevent class hierarchy from changing while
    // we are inspecting it to determine how/whether to do the inline guard.
    synchronized (VM_Class.OptCLDepManager) {
      boolean guardOverrideOnStaticCallee = false;
      if (targets == null) {
        if (verbose) VM.sysWriteln("\tNo profile data");
        // No profile information.
        // Fake up "profile data" based on static information to
        // be able to share all the decision making logic.
        if (state.isInvokeInterface()) {
          if (opts.GUARDED_INLINE_INTERFACE) {
            VM_Method singleImpl = OPT_InterfaceHierarchy.getUniqueImplementation(staticCallee);
            if (singleImpl != null && hasBody(singleImpl)) {
              if (verbose)
                VM.sysWriteln(
                    "\tFound a single implementation "
                        + singleImpl
                        + " of an interface method "
                        + staticCallee);
              targets = VM_WeightedCallTargets.create(singleImpl, 0);
              guardOverrideOnStaticCallee = true;
            }
          }
        } else {
          // invokestatic, invokevirtual, invokespecial
          if (staticCallee.isAbstract()) {
            // look for single non-abstract implementation of the abstract method
            VM_Class klass = staticCallee.getDeclaringClass();
            while (true) {
              VM_Class[] subClasses = klass.getSubClasses();
              if (subClasses.length != 1) break; // multiple subclasses => multiple targets
              VM_Method singleImpl =
                  subClasses[0].findDeclaredMethod(
                      staticCallee.getName(), staticCallee.getDescriptor());
              if (singleImpl != null && !singleImpl.isAbstract()) {
                // found something
                if (verbose) VM.sysWriteln("\tsingle impl of abstract method");
                targets = VM_WeightedCallTargets.create(singleImpl, 0);
                guardOverrideOnStaticCallee = true;
                break;
              }
              klass = subClasses[0]; // keep crawling down the hierarchy
            }
          } else {
            targets = VM_WeightedCallTargets.create(staticCallee, 0);
          }
        }
      }

      // At this point targets is either null, or accurately represents what we
      // think are the likely target(s) of the call site.
      // This information may be either derived from profile information or
      // from static heuristics. To the first approximation, we don't care which.
      // If there is a precise target, then targets contains exactly that target method.
      if (targets == null) return OPT_InlineDecision.NO("No potential targets identified");

      // Stage 3: We have one or more targets.  Determine what if anything should be done with them.
      final ArrayList methodsToInline = new ArrayList();
      final ArrayList methodsNeedGuard = new ArrayList();
      final double callSiteWeight = targets.totalWeight();
      final boolean goosc = guardOverrideOnStaticCallee; // real closures anyone?
      final boolean ps = purelyStatic; // real closures anyone?
      targets.visitTargets(
          new VM_WeightedCallTargets.Visitor() {
            public void visit(VM_Method callee, double weight) {
              if (hasBody(callee)) {
                if (verbose) {
                  VM.sysWriteln(
                      "\tEvaluating target "
                          + callee
                          + " with "
                          + weight
                          + " samples ("
                          + (100 * VM_AdaptiveInlining.adjustedWeight(weight))
                          + "%)");
                }
                // Don't inline recursively and respect no inline pragmas
                OPT_InlineSequence seq = state.getSequence();
                if (seq.containsMethod(callee)) {
                  if (verbose) VM.sysWriteln("\t\tReject: recursive");
                  return;
                }
                if (hasNoInlinePragma(callee, state)) {
                  if (verbose) VM.sysWriteln("\t\tReject: noinline pragma");
                  return;
                }

                // more or less figure out the guard situation early -- impacts size estimate.
                boolean needsGuard =
                    !state.getHasPreciseTarget()
                        && (staticCallee != callee || needsGuard(staticCallee));
                if (needsGuard && isForbiddenSpeculation(state.getRootMethod(), callee)) {
                  if (verbose) VM.sysWriteln("\t\tReject: forbidden speculation");
                  return;
                }
                boolean currentlyFinal =
                    (goosc || (staticCallee == callee))
                        && isCurrentlyFinal(callee, !opts.guardWithClassTest());
                boolean preEx =
                    needsGuard && state.getIsExtant() && opts.PREEX_INLINE && currentlyFinal;
                if (needsGuard && !preEx) {
                  if (!opts.GUARDED_INLINE) {
                    if (verbose) VM.sysWriteln("\t\tReject: guarded inlining disabled");
                    return;
                  }
                  if (!currentlyFinal && ps) {
                    if (verbose) VM.sysWriteln("\t\tReject: multiple targets and no profile data");
                    return;
                  }
                }

                // Estimate cost of performing this inlining action.
                // Includes cost of guard & off-branch call if they are going to be generated.
                boolean decideYes = false;
                if (hasInlinePragma(callee, state)) {
                  if (verbose) VM.sysWriteln("\t\tSelect: pragma inline");
                  decideYes = true;
                } else {
                  // Preserve previous inlining decisions
                  // Not the best thing in the world due to phase shifts, but
                  // it does buy some degree of stability. So, it is probably the lesser
                  // of two evils.
                  VM_CompiledMethod prev = state.getRootMethod().getCurrentCompiledMethod();
                  if (prev != null && prev.getCompilerType() == VM_CompiledMethod.OPT) {
                    if (((VM_OptCompiledMethod) prev)
                        .getMCMap()
                        .hasInlinedEdge(caller, bcIndex, callee)) {
                      if (verbose) VM.sysWriteln("\t\tSelect: Previously inlined");
                      decideYes = true;
                    }
                  }

                  if (!decideYes) {
                    int inlinedSizeEstimate = inlinedSizeEstimate((VM_NormalMethod) callee, state);
                    int cost = inliningActionCost(inlinedSizeEstimate, needsGuard, preEx, opts);
                    int maxCost = opts.IC_MAX_TARGET_SIZE;

                    if (callSiteWeight > VM_Controller.options.AI_SEED_MULTIPLIER) {
                      // real profile data with enough samples for us to trust it.
                      // Use weight and shape of call site distrubution to compute
                      // a higher maxCost.
                      double fractionOfSample = weight / callSiteWeight;
                      if (needsGuard && fractionOfSample < opts.AI_MIN_CALLSITE_FRACTION) {
                        // This call accounts for less than AI_MIN_CALLSITE_FRACTION
                        // of the profiled targets at this call site.
                        // It is highly unlikely to be profitable to inline it.
                        if (verbose)
                          VM.sysWriteln(
                              "\t\tReject: less than AI_MIN_CALLSITE_FRACTION of distribution");
                        maxCost = 0;
                      } else {
                        if (cost > maxCost) {
                          // adjust up based on weight of callsite
                          double adjustedWeight = VM_AdaptiveInlining.adjustedWeight(weight);
                          if (adjustedWeight > VM_Controller.options.AI_CONTROL_POINT) {
                            maxCost = opts.AI_MAX_TARGET_SIZE;
                          } else {
                            int range = opts.AI_MAX_TARGET_SIZE - opts.IC_MAX_TARGET_SIZE;
                            double slope =
                                ((double) range) / VM_Controller.options.AI_CONTROL_POINT;
                            int sizeAdj = (int) (slope * adjustedWeight);
                            maxCost += sizeAdj;
                          }
                        }
                      }
                    }

                    // Somewhat bogus, but if we get really deeply inlined we start backing off.
                    int curDepth = state.getInlineDepth();
                    if (curDepth > opts.IC_MAX_INLINE_DEPTH) {
                      maxCost /= (curDepth - opts.IC_MAX_INLINE_DEPTH + 1);
                    }

                    decideYes = cost <= maxCost;
                    if (verbose) {
                      if (decideYes) {
                        VM.sysWriteln(
                            "\t\tAccept: cost of " + cost + " was below threshold " + maxCost);
                      } else {
                        VM.sysWriteln(
                            "\t\tReject: cost of " + cost + " was above threshold " + maxCost);
                      }
                    }
                  }
                }

                if (decideYes) {
                  // Ok, we're going to inline it.
                  // Record that and also whether or not we think it needs a guard.
                  methodsToInline.add(callee);
                  if (preEx) {
                    if (OPT_ClassLoadingDependencyManager.TRACE
                        || OPT_ClassLoadingDependencyManager.DEBUG) {
                      VM_Class.OptCLDepManager.report(
                          "PREEX_INLINE: Inlined " + callee + " into " + caller + "\n");
                    }
                    VM_Class.OptCLDepManager.addNotOverriddenDependency(
                        callee, state.getCompiledMethod());
                    if (goosc) {
                      VM_Class.OptCLDepManager.addNotOverriddenDependency(
                          staticCallee, state.getCompiledMethod());
                    }
                    methodsNeedGuard.add(Boolean.FALSE);
                  } else {
                    methodsNeedGuard.add(Boolean.valueOf(needsGuard));
                  }
                }
              }
            }
          });

      // Stage 4: Choose guards and package up the results in an InlineDecision object
      if (methodsToInline.size() == 0) {
        OPT_InlineDecision d = OPT_InlineDecision.NO("No desirable targets");
        if (verbose) VM.sysWriteln("\tDecide: " + d);
        return d;
      } else if (methodsToInline.size() == 1) {
        VM_Method target = (VM_Method) methodsToInline.get(0);
        boolean needsGuard = ((Boolean) methodsNeedGuard.get(0)).booleanValue();
        if (needsGuard) {
          if ((guardOverrideOnStaticCallee || target == staticCallee)
              && isCurrentlyFinal(target, !opts.guardWithClassTest())) {
            OPT_InlineDecision d =
                OPT_InlineDecision.guardedYES(
                    target,
                    chooseGuard(caller, target, staticCallee, state, true),
                    "Guarded inline of single static target");
            // -#if RVM_WITH_OSR
            if (opts.OSR_GUARDED_INLINING
                && OPT_Compiler.getAppStarted()
                && VM_Controller.options.ENABLE_RECOMPILATION) {
              // note that we will OSR the failed case.
              d.setOSRTestFailed();
            }
            // -#endif
            if (verbose) VM.sysWriteln("\tDecide: " + d);
            return d;
          } else {
            OPT_InlineDecision d =
                OPT_InlineDecision.guardedYES(
                    target,
                    chooseGuard(caller, target, staticCallee, state, false),
                    "Guarded inlining of one potential target");
            if (verbose) VM.sysWriteln("\tDecide: " + d);
            return d;
          }
        } else {
          OPT_InlineDecision d = OPT_InlineDecision.YES(target, "Unique and desirable target");
          if (verbose) VM.sysWriteln("\tDecide: " + d);
          return d;
        }
      } else {
        VM_Method[] methods = new VM_Method[methodsNeedGuard.size()];
        byte[] guards = new byte[methods.length];
        int idx = 0;
        for (Iterator methodIterator = methodsToInline.iterator(),
                guardIterator = methodsNeedGuard.iterator();
            methodIterator.hasNext(); ) {
          VM_Method target = (VM_Method) methodIterator.next();
          boolean needsGuard = ((Boolean) guardIterator.next()).booleanValue();
          if (VM.VerifyAssertions) VM._assert(needsGuard);
          methods[idx] = target;
          guards[idx] = chooseGuard(caller, target, staticCallee, state, false);
          idx++;
        }
        OPT_InlineDecision d =
            OPT_InlineDecision.guardedYES(methods, guards, "Inline multiple targets");
        if (verbose) VM.sysWriteln("\tDecide: " + d);
        return d;
      }
    }
  }