Examples with ContextCFG com.jopdesign.common.code.SuperGraph.ContextCFG used on opensource projects

Example 6 with ContextCFG

use of com.jopdesign.common.code.SuperGraph.ContextCFG in project jop by jop-devel.

the class Segment method methodSegment.

/**
	 * Create an interprocedural segment for a method
	 * @param targetMethod The method to build a segment for
	 * @param callString   The context for the method
	 * @param cfgProvider A control flow graph provider
	 * @param callStringLength Length of the callstrings
	 * @param infeasibles Information about infeasible edges (null if no information available)
	 *
	 * @return a segment representing executions of the method (not including the virtual entry and exit nodes)
	 */
public static Segment methodSegment(MethodInfo targetMethod, CallString callString, CFGProvider cfgProvider, int callStringLength, InfeasibleEdgeProvider infeasibles) {
    if (infeasibles == null) {
        infeasibles = InfeasibleEdgeProvider.NO_INFEASIBLES;
    }
    SuperGraph superGraph = new SuperGraph(cfgProvider, cfgProvider.getFlowGraph(targetMethod), callString, callStringLength, infeasibles);
    ContextCFG rootMethod = superGraph.getRootNode();
    Set<SuperGraphEdge> entryEdges = Iterators.addAll(new HashSet<SuperGraphEdge>(), superGraph.getCFGEntryEdges(rootMethod)), exitEdges = Iterators.addAll(new HashSet<SuperGraphEdge>(), superGraph.getCFGExitEdges(rootMethod));
    return new Segment(superGraph, entryEdges, exitEdges);
}

Example 7 with ContextCFG

use of com.jopdesign.common.code.SuperGraph.ContextCFG in project jop by jop-devel.

the class GlobalAnalysis method getInfeasibleEdgeConstraints.

/**
	 * For each infeasible edge, assert that the edge has flow 0
	 * @param wcetTool
	 * @param segment
	 * @return
	 */
private static Iterable<LinearConstraint<SuperGraphEdge>> getInfeasibleEdgeConstraints(WCETTool wcetTool, Segment segment) {
    List<LinearConstraint<SuperGraphEdge>> constraints = new ArrayList<LinearConstraint<SuperGraphEdge>>();
    // -- edge = 0
    for (ContextCFG ccfg : segment.getCallGraphNodes()) {
        for (CFGEdge edge : wcetTool.getInfeasibleEdges(ccfg.getCfg(), ccfg.getCallString())) {
            LinearConstraint<SuperGraphEdge> infeasibleConstraint = new LinearConstraint<SuperGraphEdge>(ConstraintType.Equal);
            infeasibleConstraint.addLHS(segment.liftCFGEdges(ccfg, Iterators.singleton(edge)));
            infeasibleConstraint.addRHS(0);
            constraints.add(infeasibleConstraint);
        }
    }
    return constraints;
}

Example 8 with ContextCFG

use of com.jopdesign.common.code.SuperGraph.ContextCFG in project jop by jop-devel.

the class WCETAnalysis method runBlockingTimeAnalysis.

private void runBlockingTimeAnalysis(MethodInfo targetMethod) throws InvalidFlowFactException, LpSolveException, UnsupportedCacheModelException {
    GlobalAnalysis an = new GlobalAnalysis(wcetTool, ipetConfig);
    CacheCostCalculationMethod requestedCacheApprox = IPETConfig.getRequestedCacheApprox(config);
    /* Find all synchronized segments */
    Segment target = Segment.methodSegment(targetMethod, CallString.EMPTY, wcetTool, wcetTool.getCallstringLength(), wcetTool);
    ArrayList<SynchronizedBlockResult> sBlocks = new ArrayList<SynchronizedBlockResult>();
    for (ContextCFG ccfg : target.getCallGraphNodes()) {
        for (CFGNode cfgNode : ccfg.getCfg().vertexSet()) {
            if (cfgNode.getBasicBlock() == null)
                continue;
            for (InstructionHandle ih : cfgNode.getBasicBlock().getInstructions()) {
                if (ih.getInstruction() instanceof MONITORENTER) {
                    /* compute synchronized block WCET */
                    Segment synchronizedSegment = Segment.synchronizedSegment(ccfg, cfgNode, ih, wcetTool, wcetTool.getCallstringLength(), wcetTool);
                    wcet = an.computeWCET(targetMethod.getShortName(), synchronizedSegment, requestedCacheApprox);
                    sBlocks.add(new SynchronizedBlockResult(sBlocks.size(), synchronizedSegment, cfgNode, ih, wcet));
                }
            }
        }
    }
    /* check nested synchronized blocks */
    for (SynchronizedBlockResult sBlock : sBlocks) {
        for (SynchronizedBlockResult otherBlock : sBlocks) {
            if (sBlock == otherBlock)
                continue;
            for (SuperGraphEdge entryEdge : otherBlock.synchronizedSegment.getEntryEdges()) {
                if (sBlock.synchronizedSegment.includesEdge(entryEdge)) {
                    sBlock.nested.add(otherBlock);
                    break;
                }
            }
        }
    }
    System.out.println("=== Synchronized Blocks ===");
    for (SynchronizedBlockResult sBlock : sBlocks) {
        sBlock.dump(System.out);
    }
}

Example 9 with ContextCFG

use of com.jopdesign.common.code.SuperGraph.ContextCFG in project jop by jop-devel.

the class ObjectCacheAnalysis method findPersistenceSegmentCover.

/** Find a segment cover (i.e., a set of segments covering all execution paths)
	 *  where each segment in the set is persistent (a cache persistence region (CPR))
	 *  
	 *  <h2>The simplest algorithm for a segment S (for acyclic callgraphs)</h2>
	 *   <ul><li/>Check whether S itself is CPR; if so, return S
	 *       <li/>Otherwise, create subsegments S' for each invoked method,
	 *       <li/>and single node segments for each access
	 *   </ul>
	 * @param segment the parent segment
	 * @param checks the strategy to use to determine whether a segment is a persistence region
	 * @param avoidOverlap whether overlapping segments should be avoided
	 * @param alwaysMissNodes additional node set considered to be always miss
	 * @return
	 * @throws LpSolveException 
	 * @throws InvalidFlowFactException 
	 */
protected Collection<Segment> findPersistenceSegmentCover(Segment segment, EnumSet<PersistenceCheck> checks, boolean avoidOverlap, Set<SuperGraphNode> alwaysMissNodes) throws InvalidFlowFactException, LpSolveException {
    List<Segment> cover = new ArrayList<Segment>();
    /* We currently only support entries to one CFG */
    Set<ContextCFG> entryMethods = new HashSet<ContextCFG>();
    for (SuperGraphEdge entryEdge : segment.getEntryEdges()) {
        entryMethods.add(entryEdge.getTarget().getContextCFG());
    }
    ContextCFG entryMethod;
    if (entryMethods.size() != 1) {
        throw new AssertionError("findPersistenceSegmentCover: only supporting segments with unique entry method");
    } else {
        entryMethod = entryMethods.iterator().next();
    }
    if (this.isPersistenceRegion(segment, checks)) {
        cover.add(segment);
    } else {
        /* method sub segments */
        for (Pair<SuperInvokeEdge, SuperReturnEdge> invocation : segment.getCallSitesFrom(entryMethod)) {
            ContextCFG callee = invocation.first().getCallee();
            // System.err.println("Recursively analyzing: "+callee);
            Segment subSegment = Segment.methodSegment(callee, segment.getSuperGraph());
            cover.addAll(findPersistenceSegmentCover(subSegment, checks, avoidOverlap, alwaysMissNodes));
        }
        /* always miss nodes (not covered) */
        alwaysMissNodes.addAll(segment.getNodes(entryMethod));
    }
    return cover;
}

Example 10 with ContextCFG

use of com.jopdesign.common.code.SuperGraph.ContextCFG in project jop by jop-devel.

the class SegmentTest method main.

public static void main(String[] args) {
    TestFramework testFramework = new TestFramework();
    AppSetup setup = testFramework.setupAppSetup("java/tools/test/test/cg1.zip", null);
    AppInfo appInfo = testFramework.setupAppInfo("wcet.devel.CallGraph1.run", true);
    SegmentTest testInst = new SegmentTest();
    testInst.appInfo = appInfo;
    MethodInfo mainMethod = appInfo.getMainMethod();
    /* count total number of CFG nodes */
    SuperGraph superGraph = new SuperGraph(testInst, testInst.getFlowGraph(mainMethod), 2);
    Segment segment = Segment.methodSegment(mainMethod, CallString.EMPTY, testInst, 2, superGraph.getInfeasibleEdgeProvider());
    int count = 0;
    for (ContextCFG cgNode : superGraph.getCallGraphNodes()) {
        try {
            cgNode.getCfg().exportDOT(new File("/tmp/cfg-" + cgNode.getCfg().getMethodInfo().getClassName() + "_" + cgNode.getCfg().getMethodInfo().getShortName() + ".dot"));
        } catch (IOException e) {
        }
        count += cgNode.getCfg().vertexSet().size();
    }
    checkEquals("[Segment 1] Expected node count", (count - 2), Iterators.size(segment.getNodes()));
    try {
        segment.exportDOT(new File("/tmp/cg1-segment.dot"));
    } catch (IOException e) {
        e.printStackTrace();
    }
    /* root */
    ContextCFG root = superGraph.getRootNode();
    /* Build a segment cuts all invokes in those methods invoked by run() */
    Segment segment2;
    /* root entries */
    Set<SuperGraphEdge> entries = new HashSet<SuperGraphEdge>();
    Iterators.addAll(entries, superGraph.liftCFGEdges(root, root.getCfg().outgoingEdgesOf(root.getCfg().getEntry())));
    Set<SuperGraphEdge> exits = new HashSet<SuperGraphEdge>();
    int cfgNodeCandidateCount = root.getCfg().vertexSet().size();
    /* find callees */
    for (SuperEdge superEdge : superGraph.getCallGraph().outgoingEdgesOf(root)) {
        if (!(superEdge instanceof SuperInvokeEdge))
            continue;
        ContextCFG callee1 = superGraph.getCallGraph().getEdgeTarget(superEdge);
        cfgNodeCandidateCount += callee1.getCfg().vertexSet().size();
        /* find all edges from invoke nodes */
        for (CFGNode cfgNode : callee1.getCfg().vertexSet()) {
            if (cfgNode instanceof InvokeNode) {
                Iterators.addAll(exits, superGraph.outgoingEdgesOf(new SuperGraphNode(callee1, cfgNode)));
            }
        }
    }
    segment2 = new Segment(superGraph, entries, exits);
    exits = segment2.getExitEdges();
    /* reachable exits */
    try {
        segment2.exportDOT(new File("/tmp/cg1-segment2.dot"));
    } catch (IOException e) {
        e.printStackTrace();
    }
    checkEquals("[Segment 2] Expected node count", 14, Iterators.size(segment2.getNodes()) + 2);
    checkLessEqual("[Segment 2] Expected node count <= |root + directly invoked|", Iterators.size(segment2.getNodes()) + 2, cfgNodeCandidateCount);
    /* Another segment, with entries the exits of the last segment, and exits all invokes in methods the entries */
    Segment segment3;
    entries = segment2.getExitEdges();
    exits = new HashSet<SuperGraphEdge>();
    cfgNodeCandidateCount = 0;
    for (SuperGraphEdge superEdge : entries) {
        SuperGraphNode node1 = superEdge.getTarget();
        for (SuperEdge superEdge2 : superGraph.getCallGraph().outgoingEdgesOf(node1.getContextCFG())) {
            if (!(superEdge2 instanceof SuperInvokeEdge))
                continue;
            ContextCFG callee2 = superGraph.getCallGraph().getEdgeTarget(superEdge2);
            /* find all edges from invoke nodes */
            for (CFGNode cfgNode : callee2.getCfg().vertexSet()) {
                if (cfgNode instanceof InvokeNode) {
                    Iterators.addAll(exits, superGraph.outgoingEdgesOf(new SuperGraphNode(callee2, cfgNode)));
                }
            }
        }
    }
    segment3 = new Segment(superGraph, entries, exits);
    try {
        segment3.exportDOT(new File("/tmp/cg1-segment3.dot"));
    } catch (IOException e) {
        e.printStackTrace();
    }
    checkEquals("[Segment 2] 3 exits", 3, segment2.getExitEdges().size());
    checkEquals("[Segment 3] 3 entries", 3, segment3.getEntryEdges().size());
    checkEquals("[Segment 3] 4 exits", 4, segment3.getExitEdges().size());
}