Examples with MultiRunStatementsFinder soot.jimple.toolkits.thread.mhp.findobject.MultiRunStatementsFinder used on opensource projects

Example 1 with MultiRunStatementsFinder

use of soot.jimple.toolkits.thread.mhp.findobject.MultiRunStatementsFinder in project soot by Sable.

the class SynchObliviousMhpAnalysis method run.

public void run() {
    SootMethod mainMethod = Scene.v().getMainClass().getMethodByName("main");
    PointsToAnalysis pta = Scene.v().getPointsToAnalysis();
    if (pta instanceof DemandCSPointsTo) {
        DemandCSPointsTo demandCSPointsTo = (DemandCSPointsTo) pta;
        pta = demandCSPointsTo.getPAG();
    }
    if (!(pta instanceof PAG)) {
        throw new RuntimeException("You must use Spark for points-to analysis when computing MHP information!");
    }
    PAG pag = (PAG) pta;
    SparkOptions so = pag.getOpts();
    if (so.rta())
        throw new RuntimeException("MHP cannot be calculated using RTA due to incomplete call graph");
    CallGraph callGraph = Scene.v().getCallGraph();
    // Get a call graph trimmed to contain only the relevant methods (non-lib, non-native)
    // logger.debug("    MHP: PegCallGraph");
    PegCallGraph pecg = new PegCallGraph(callGraph);
    // Find allocation nodes that are run more than once
    // Also find methods that are run more than once
    // logger.debug("    MHP: AllocNodesFinder");
    AllocNodesFinder anf = new AllocNodesFinder(pecg, callGraph, (PAG) pta);
    Set<AllocNode> multiRunAllocNodes = anf.getMultiRunAllocNodes();
    Set<SootMethod> multiCalledMethods = anf.getMultiCalledMethods();
    // Find Thread.start() and Thread.join() statements (in live code)
    // logger.debug("    MHP: StartJoinFinder");
    // does analysis
    StartJoinFinder sjf = new StartJoinFinder(callGraph, (PAG) pta);
    Map<Stmt, List<AllocNode>> startToAllocNodes = sjf.getStartToAllocNodes();
    Map<Stmt, List<SootMethod>> startToRunMethods = sjf.getStartToRunMethods();
    Map<Stmt, SootMethod> startToContainingMethod = sjf.getStartToContainingMethod();
    Map<Stmt, Stmt> startToJoin = sjf.getStartToJoin();
    // Build MHP Lists
    // logger.debug("    MHP: Building MHP Lists");
    List<AbstractRuntimeThread> runAtOnceCandidates = new ArrayList<AbstractRuntimeThread>();
    Iterator threadIt = startToRunMethods.entrySet().iterator();
    int threadNum = 0;
    while (threadIt.hasNext()) {
        // Get list of possible Runnable.run methods (actually, a list of peg chains)
        // and a list of allocation sites for this thread start statement
        // and the thread start statement itself
        Map.Entry e = (Map.Entry) threadIt.next();
        Stmt startStmt = (Stmt) e.getKey();
        List runMethods = (List) e.getValue();
        List threadAllocNodes = startToAllocNodes.get(e.getKey());
        // Get a list of all possible unique Runnable.run methods for this thread start statement
        // provides a list interface to the methods in a thread's sub-call-graph
        AbstractRuntimeThread thread = new AbstractRuntimeThread();
        thread.setStartStmt(startStmt);
        // List threadMethods = new ArrayList();
        Iterator runMethodsIt = runMethods.iterator();
        while (runMethodsIt.hasNext()) {
            SootMethod method = (SootMethod) runMethodsIt.next();
            if (!thread.containsMethod(method)) {
                thread.addMethod(method);
                thread.addRunMethod(method);
            }
        }
        // Get a list containing all methods in the call graph(s) rooted at the possible run methods for this thread start statement
        // AKA a list of all methods that might be called by the thread started here
        int methodNum = 0;
        while (// iterate over all methods in threadMethods, even as new methods are being added to it
        methodNum < thread.methodCount()) {
            Iterator succMethodsIt = pecg.getSuccsOf(thread.getMethod(methodNum)).iterator();
            while (succMethodsIt.hasNext()) {
                SootMethod method = (SootMethod) succMethodsIt.next();
                // if all edges into this method are of Kind THREAD, ignore it
                // (because it's a run method that won't be called as part of THIS thread) THIS IS NOT OPTIMAL
                boolean ignoremethod = true;
                Iterator edgeInIt = callGraph.edgesInto(method);
                while (edgeInIt.hasNext()) {
                    Edge edge = (Edge) edgeInIt.next();
                    if (edge.kind() != Kind.THREAD && edge.kind() != Kind.EXECUTOR && edge.kind() != Kind.ASYNCTASK && // called directly by any of the thread methods?
                    thread.containsMethod(edge.src()))
                        ignoremethod = false;
                }
                if (!ignoremethod && !thread.containsMethod(method))
                    thread.addMethod(method);
            }
            methodNum++;
        }
        // Add this list of methods to MHPLists
        threadList.add(thread);
        if (optionPrintDebug)
            System.out.println(thread.toString());
        // Find out if the "thread" in "thread.start()" could be more than one object
        boolean mayStartMultipleThreadObjects = (threadAllocNodes.size() > 1) || so.types_for_sites();
        if (// if there's only one alloc node
        !mayStartMultipleThreadObjects) {
            if (// but it gets run more than once
            multiRunAllocNodes.contains(threadAllocNodes.iterator().next())) {
                // then "thread" in "thread.start()" could be more than one object
                mayStartMultipleThreadObjects = true;
            }
        }
        if (mayStartMultipleThreadObjects)
            thread.setStartStmtHasMultipleReachingObjects();
        // Find out if the "thread.start()" statement may be run more than once
        SootMethod startStmtMethod = startToContainingMethod.get(startStmt);
        thread.setStartStmtMethod(startStmtMethod);
        // if method is called more than once...
        boolean mayBeRunMultipleTimes = multiCalledMethods.contains(startStmtMethod);
        if (!mayBeRunMultipleTimes) {
            UnitGraph graph = new CompleteUnitGraph(startStmtMethod.getActiveBody());
            MultiRunStatementsFinder finder = new MultiRunStatementsFinder(graph, startStmtMethod, multiCalledMethods, callGraph);
            // list of all units that may be run more than once in this method
            FlowSet multiRunStatements = finder.getMultiRunStatements();
            if (multiRunStatements.contains(startStmt))
                mayBeRunMultipleTimes = true;
        }
        if (mayBeRunMultipleTimes) {
            thread.setStartStmtMayBeRunMultipleTimes();
        }
        // by one thread (sounds strict, but actually this is the most common case)
        if (mayBeRunMultipleTimes && startToJoin.containsKey(startStmt)) {
            thread.setJoinStmt(startToJoin.get(startStmt));
            // well, actually, we don't know yet
            mayBeRunMultipleTimes = false;
            methodNum = 0;
            List<SootMethod> containingMethodCalls = new ArrayList<SootMethod>();
            containingMethodCalls.add(startStmtMethod);
            while (// iterate over all methods in threadMethods, even as new methods are being added to it
            methodNum < containingMethodCalls.size()) {
                Iterator succMethodsIt = pecg.getSuccsOf(containingMethodCalls.get(methodNum)).iterator();
                while (succMethodsIt.hasNext()) {
                    SootMethod method = (SootMethod) succMethodsIt.next();
                    if (method == startStmtMethod) {
                        // this method is reentrant
                        // this time it's for sure
                        mayBeRunMultipleTimes = true;
                        thread.setStartMethodIsReentrant();
                        thread.setRunsMany();
                        break;
                    }
                    if (!containingMethodCalls.contains(method))
                        containingMethodCalls.add(method);
                }
                methodNum++;
            }
            if (!mayBeRunMultipleTimes) {
                // There's still one thing that might cause this to be run multiple times: if it can be run in parallel with itself
                // but we can't find that out 'till we're done
                runAtOnceCandidates.add(thread);
            }
        }
        // then add this list of methods to MHPLists *AGAIN*
        if (optionPrintDebug)
            System.out.println("Start Stmt " + startStmt.toString() + " mayStartMultipleThreadObjects=" + mayStartMultipleThreadObjects + " mayBeRunMultipleTimes=" + mayBeRunMultipleTimes);
        if (mayStartMultipleThreadObjects && mayBeRunMultipleTimes) {
            // add another copy
            threadList.add(thread);
            thread.setRunsMany();
            if (optionPrintDebug)
                System.out.println(thread.toString());
        } else
            thread.setRunsOnce();
        threadNum++;
    }
    // do same for main method
    AbstractRuntimeThread mainThread = new AbstractRuntimeThread();
    // List mainMethods = new ArrayList();
    threadList.add(mainThread);
    mainThread.setRunsOnce();
    mainThread.addMethod(mainMethod);
    mainThread.addRunMethod(mainMethod);
    mainThread.setIsMainThread();
    // get all the successors, add to threadMethods
    int methodNum = 0;
    while (methodNum < mainThread.methodCount()) {
        Iterator succMethodsIt = pecg.getSuccsOf(mainThread.getMethod(methodNum)).iterator();
        while (succMethodsIt.hasNext()) {
            SootMethod method = (SootMethod) succMethodsIt.next();
            // if all edges into this are of Kind THREAD, ignore it
            boolean ignoremethod = true;
            Iterator edgeInIt = callGraph.edgesInto(method);
            while (edgeInIt.hasNext()) {
                if (((Edge) edgeInIt.next()).kind() != Kind.THREAD)
                    ignoremethod = false;
            }
            if (!ignoremethod && !mainThread.containsMethod(method))
                mainThread.addMethod(method);
        }
        methodNum++;
    }
    if (optionPrintDebug)
        logger.debug("" + mainThread.toString());
    // Revisit the containing methods of start-join pairs that are non-reentrant but might be called in parallel
    boolean addedNew = true;
    while (addedNew) {
        addedNew = false;
        ListIterator<AbstractRuntimeThread> it = runAtOnceCandidates.listIterator();
        while (it.hasNext()) {
            AbstractRuntimeThread someThread = it.next();
            SootMethod someStartMethod = someThread.getStartStmtMethod();
            if (mayHappenInParallelInternal(someStartMethod, someStartMethod)) {
                // add a second copy of it
                threadList.add(someThread);
                someThread.setStartMethodMayHappenInParallel();
                someThread.setRunsMany();
                it.remove();
                if (optionPrintDebug)
                    logger.debug("" + someThread.toString());
                addedNew = true;
            }
        }
    }
    // mark the remaining threads here as run-one-at-a-time
    Iterator<AbstractRuntimeThread> it = runAtOnceCandidates.iterator();
    while (it.hasNext()) {
        AbstractRuntimeThread someThread = it.next();
        someThread.setRunsOneAtATime();
    }
}