Пример #1
0
 private static void checkWatchList(
     ArrayList<FloatingReadNode> watchList,
     LocationIdentity identity,
     Block b,
     ArrayList<Node> result,
     NodeMap<Block> nodeMap,
     NodeBitMap unprocessed) {
   assert identity.isMutable();
   if (identity.isAny()) {
     for (FloatingReadNode r : watchList) {
       if (unprocessed.isMarked(r)) {
         sortIntoList(r, b, result, nodeMap, unprocessed, null);
       }
     }
     watchList.clear();
   } else {
     int index = 0;
     while (index < watchList.size()) {
       FloatingReadNode r = watchList.get(index);
       LocationIdentity locationIdentity = r.getLocationIdentity();
       assert locationIdentity.isMutable();
       if (unprocessed.isMarked(r)) {
         if (identity.overlaps(locationIdentity)) {
           sortIntoList(r, b, result, nodeMap, unprocessed, null);
         } else {
           ++index;
           continue;
         }
       }
       int lastIndex = watchList.size() - 1;
       watchList.set(index, watchList.get(lastIndex));
       watchList.remove(lastIndex);
     }
   }
 }
 @Override
 public LocationIdentity getLocationIdentity() {
   /*
    * Because of restrictions that the memory graph of snippets matches the original node,
    * pretend that we kill any.
    */
   return LocationIdentity.any();
 }
  private void processLocation(
      Node n, LocationIdentity location, Set<FloatingReadNode> currentState) {
    assert n != null;
    if (location.isImmutable()) {
      return;
    }

    for (FloatingReadNode r : cloneState(currentState)) {
      if (r.getLocationIdentity().overlaps(location)) {
        // This read is killed by this location.
        currentState.remove(r);
      }
    }
  }
 @Override
 public LocationIdentity getLocationIdentity() {
   return LocationIdentity.any();
 }
Пример #5
0
    private static void resortEarliestWithinBlock(
        Block b,
        BlockMap<List<Node>> blockToNodes,
        NodeMap<Block> nodeToBlock,
        NodeBitMap unprocessed) {
      ArrayList<FloatingReadNode> watchList = new ArrayList<>();
      List<Node> oldList = blockToNodes.get(b);
      AbstractBeginNode beginNode = b.getBeginNode();
      for (Node n : oldList) {
        if (n instanceof FloatingReadNode) {
          FloatingReadNode floatingReadNode = (FloatingReadNode) n;
          LocationIdentity locationIdentity = floatingReadNode.getLocationIdentity();
          MemoryNode lastLocationAccess = floatingReadNode.getLastLocationAccess();
          if (locationIdentity.isMutable() && lastLocationAccess != null) {
            ValueNode lastAccessLocation = lastLocationAccess.asNode();
            if (nodeToBlock.get(lastAccessLocation) == b
                && lastAccessLocation != beginNode
                && !(lastAccessLocation instanceof MemoryPhiNode)) {
              // This node's last access location is within this block. Add to watch
              // list when processing the last access location.
            } else {
              watchList.add(floatingReadNode);
            }
          }
        }
      }

      ArrayList<Node> newList = new ArrayList<>(oldList.size());
      assert oldList.get(0) == beginNode;
      unprocessed.clear(beginNode);
      newList.add(beginNode);
      for (int i = 1; i < oldList.size(); ++i) {
        Node n = oldList.get(i);
        if (unprocessed.isMarked(n)) {
          if (n instanceof MemoryNode) {
            if (n instanceof MemoryCheckpoint) {
              assert n instanceof FixedNode;
              if (watchList.size() > 0) {
                // Check whether we need to commit reads from the watch list.
                checkWatchList(b, nodeToBlock, unprocessed, newList, watchList, n);
              }
            }
            // Add potential dependent reads to the watch list.
            for (Node usage : n.usages()) {
              if (usage instanceof FloatingReadNode) {
                FloatingReadNode floatingReadNode = (FloatingReadNode) usage;
                if (nodeToBlock.get(floatingReadNode) == b
                    && floatingReadNode.getLastLocationAccess() == n
                    && !(n instanceof MemoryPhiNode)) {
                  watchList.add(floatingReadNode);
                }
              }
            }
          }
          assert unprocessed.isMarked(n);
          unprocessed.clear(n);
          newList.add(n);
        } else {
          // This node was pulled up.
          assert !(n instanceof FixedNode) : n;
        }
      }

      for (Node n : newList) {
        unprocessed.mark(n);
      }

      assert newList.size() == oldList.size();
      blockToNodes.put(b, newList);
    }
Пример #6
0
    @SuppressFBWarnings(
        value = "RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE",
        justification = "false positive found by findbugs")
    private BlockMap<ArrayList<FloatingReadNode>> calcLatestBlocks(
        SchedulingStrategy strategy,
        NodeMap<Block> currentNodeMap,
        BlockMap<List<Node>> earliestBlockToNodesMap,
        NodeBitMap visited,
        BlockMap<List<Node>> latestBlockToNodesMap,
        boolean immutableGraph) {
      BlockMap<ArrayList<FloatingReadNode>> watchListMap = new BlockMap<>(cfg);
      Block[] reversePostOrder = cfg.reversePostOrder();
      for (int j = reversePostOrder.length - 1; j >= 0; --j) {
        Block currentBlock = reversePostOrder[j];
        List<Node> blockToNodes = earliestBlockToNodesMap.get(currentBlock);
        LocationSet killed = null;
        int previousIndex = blockToNodes.size();
        for (int i = blockToNodes.size() - 1; i >= 0; --i) {
          Node currentNode = blockToNodes.get(i);
          assert currentNodeMap.get(currentNode) == currentBlock;
          assert !(currentNode instanceof PhiNode) && !(currentNode instanceof ProxyNode);
          assert visited.isMarked(currentNode);
          if (currentNode instanceof FixedNode) {
            // For these nodes, the earliest is at the same time the latest block.
          } else {
            Block latestBlock = null;

            LocationIdentity constrainingLocation = null;
            if (currentNode instanceof FloatingReadNode) {
              // We are scheduling a floating read node => check memory
              // anti-dependencies.
              FloatingReadNode floatingReadNode = (FloatingReadNode) currentNode;
              LocationIdentity location = floatingReadNode.getLocationIdentity();
              if (location.isMutable()) {
                // Location can be killed.
                constrainingLocation = location;
                if (currentBlock.canKill(location)) {
                  if (killed == null) {
                    killed = new LocationSet();
                  }
                  fillKillSet(killed, blockToNodes.subList(i + 1, previousIndex));
                  previousIndex = i;
                  if (killed.contains(location)) {
                    // Earliest block kills location => we need to stay within
                    // earliest block.
                    latestBlock = currentBlock;
                  }
                }
              }
            }

            if (latestBlock == null) {
              // We are not constraint within earliest block => calculate optimized
              // schedule.
              calcLatestBlock(
                  currentBlock,
                  strategy,
                  currentNode,
                  currentNodeMap,
                  constrainingLocation,
                  watchListMap,
                  latestBlockToNodesMap,
                  visited,
                  immutableGraph);
            } else {
              selectLatestBlock(
                  currentNode,
                  currentBlock,
                  latestBlock,
                  currentNodeMap,
                  watchListMap,
                  constrainingLocation,
                  latestBlockToNodesMap);
            }
          }
        }
      }
      return watchListMap;
    }