@Override
  public void notifyCompilationTruffleTierFinished(
      OptimizedCallTarget target, TruffleInlining inliningDecision, StructuredGraph graph) {
    compilationLocal.get().truffleTierFinished = System.nanoTime();

    nodeStatistics.accept(
        target.nodeStream(inliningDecision).filter(n -> n != null).map(node -> node.getClass()));

    CallTargetNodeStatistics callTargetStat =
        new CallTargetNodeStatistics(target, inliningDecision);
    nodeCount.accept(callTargetStat.getNodeCount());
    nodeCountTrivial.accept(callTargetStat.getNodeCountTrivial());
    nodeCountNonTrivial.accept(callTargetStat.getNodeCountNonTrivial());
    nodeCountMonomorphic.accept(callTargetStat.getNodeCountMonomorphic());
    nodeCountPolymorphic.accept(callTargetStat.getNodeCountPolymorphic());
    nodeCountMegamorphic.accept(callTargetStat.getNodeCountMegamorphic());

    callCount.accept(callTargetStat.getCallCount());
    callCountIndirect.accept(callTargetStat.getCallCountIndirect());
    callCountDirect.accept(callTargetStat.getCallCountDirect());
    callCountDirectDispatched.accept(callTargetStat.getCallCountDirectDispatched());
    callCountDirectInlined.accept(callTargetStat.getCallCountDirectInlined());
    callCountDirectCloned.accept(callTargetStat.getCallCountDirectCloned());
    callCountDirectNotCloned.accept(callTargetStat.getCallCountDirectNotCloned());
    loopCount.accept(callTargetStat.getLoopCount());

    truffleTierNodeCount.accept(graph.getNodeCount());
    if (TruffleCompilerOptions.TruffleCompilationStatisticDetails.getValue()) {
      truffleTierNodeStatistics.accept(nodeClassStream(graph));
    }
  }
 public boolean continueInlining(StructuredGraph currentGraph) {
   if (currentGraph.getNodeCount() >= MaximumDesiredSize.getValue()) {
     InliningUtil.logInliningDecision("inlining is cut off by MaximumDesiredSize");
     metricInliningStoppedByMaxDesiredSize.increment();
     return false;
   }
   return true;
 }
  @Override
  public void notifyCompilationGraalTierFinished(
      OptimizedCallTarget target, StructuredGraph graph) {
    compilationLocal.get().graalTierFinished = System.nanoTime();
    graalTierNodeCount.accept(graph.getNodeCount());

    if (TruffleCompilerOptions.TruffleCompilationStatisticDetails.getValue()) {
      graalTierNodeStatistics.accept(nodeClassStream(graph));
    }
  }
  @Override
  public void run(StructuredGraph graph) {
    if (optional && Options.ReduceDCE.getValue()) {
      return;
    }

    NodeFlood flood = graph.createNodeFlood();
    int totalNodeCount = graph.getNodeCount();
    flood.add(graph.start());
    iterateSuccessorsAndInputs(flood);
    int totalMarkedCount = flood.getTotalMarkedCount();
    if (totalNodeCount == totalMarkedCount) {
      // All nodes are live => nothing more to do.
      return;
    } else {
      // Some nodes are not marked alive and therefore dead => proceed.
      assert totalNodeCount > totalMarkedCount;
    }

    deleteNodes(flood, graph);
  }
示例#5
0
    private void scheduleEarliestIterative(
        BlockMap<List<Node>> blockToNodes,
        NodeMap<Block> nodeToBlock,
        NodeBitMap visited,
        StructuredGraph graph,
        boolean immutableGraph) {

      BitSet floatingReads = new BitSet(cfg.getBlocks().length);

      // Add begin nodes as the first entry and set the block for phi nodes.
      for (Block b : cfg.getBlocks()) {
        AbstractBeginNode beginNode = b.getBeginNode();
        ArrayList<Node> nodes = new ArrayList<>();
        nodeToBlock.set(beginNode, b);
        nodes.add(beginNode);
        blockToNodes.put(b, nodes);

        if (beginNode instanceof AbstractMergeNode) {
          AbstractMergeNode mergeNode = (AbstractMergeNode) beginNode;
          for (PhiNode phi : mergeNode.phis()) {
            nodeToBlock.set(phi, b);
          }
        } else if (beginNode instanceof LoopExitNode) {
          LoopExitNode loopExitNode = (LoopExitNode) beginNode;
          for (ProxyNode proxy : loopExitNode.proxies()) {
            nodeToBlock.set(proxy, b);
          }
        }
      }

      NodeStack stack = new NodeStack();

      // Start analysis with control flow ends.
      Block[] reversePostOrder = cfg.reversePostOrder();
      for (int j = reversePostOrder.length - 1; j >= 0; --j) {
        Block b = reversePostOrder[j];
        FixedNode endNode = b.getEndNode();
        if (isFixedEnd(endNode)) {
          stack.push(endNode);
          nodeToBlock.set(endNode, b);
        }
      }

      processStack(cfg, blockToNodes, nodeToBlock, visited, floatingReads, stack);

      // Visit back input edges of loop phis.
      boolean changed;
      boolean unmarkedPhi;
      do {
        changed = false;
        unmarkedPhi = false;
        for (LoopBeginNode loopBegin : graph.getNodes(LoopBeginNode.TYPE)) {
          for (PhiNode phi : loopBegin.phis()) {
            if (visited.isMarked(phi)) {
              for (int i = 0; i < loopBegin.getLoopEndCount(); ++i) {
                Node node = phi.valueAt(i + loopBegin.forwardEndCount());
                if (node != null && !visited.isMarked(node)) {
                  changed = true;
                  stack.push(node);
                  processStack(cfg, blockToNodes, nodeToBlock, visited, floatingReads, stack);
                }
              }
            } else {
              unmarkedPhi = true;
            }
          }
        }

        /*
         * the processing of one loop phi could have marked a previously checked loop phi,
         * therefore this needs to be iterative.
         */
      } while (unmarkedPhi && changed);

      // Check for dead nodes.
      if (!immutableGraph && visited.getCounter() < graph.getNodeCount()) {
        for (Node n : graph.getNodes()) {
          if (!visited.isMarked(n)) {
            n.clearInputs();
            n.markDeleted();
          }
        }
      }

      // Add end nodes as the last nodes in each block.
      for (Block b : cfg.getBlocks()) {
        FixedNode endNode = b.getEndNode();
        if (isFixedEnd(endNode)) {
          if (endNode != b.getBeginNode()) {
            addNode(blockToNodes, b, endNode);
          }
        }
      }

      if (!floatingReads.isEmpty()) {
        for (Block b : cfg.getBlocks()) {
          if (floatingReads.get(b.getId())) {
            resortEarliestWithinBlock(b, blockToNodes, nodeToBlock, visited);
          }
        }
      }

      assert MemoryScheduleVerification.check(cfg.getStartBlock(), blockToNodes);
    }