Examples with FaultASTBuilder edu.umn.cs.crisys.safety.analysis.transform.FaultASTBuilder used on opensource projects

Example 1 with FaultASTBuilder

use of edu.umn.cs.crisys.safety.analysis.transform.FaultASTBuilder in project AMASE by loonwerks.

the class AddFaultsToNodeVisitor method gatherFaults.

/**
 * Method gathers fault statements within this agree node and begins processing.
 * Creates FaultASTBuilder object, creates faults for each fault stmt, populates
 * asym maps, separates asym/sym faults for separate processing, and returns
 * processed faults.
 *
 * @param globalLustreNodes List of Nodes
 * @param node              This agree node
 * @param isTop             flag to determine if this is the top node of the
 *                          program.
 * @return list of faults associated with the fault stmts in this node.
 */
public List<Fault> gatherFaults(List<Node> globalLustreNodes, AgreeNode node, boolean isTop) {
    List<SpecStatement> specs = SafetyUtil.collapseAnnexes(SafetyUtil.getSafetyAnnexes(node, isTop));
    List<Fault> faults = new ArrayList<>();
    // reset fault count for the new Agree Node
    FaultASTBuilder.resetFaultCounter();
    // Before looping through spec statements, separate out the asymmetric multiple
    // faults on a single output with the sym/asym single faults on a single output.
    // 1. Collect all fault statements and put into list.
    // Do not collect any that are disabled.
    // 2. Separate out multiple asym faults on one output and single faults on one
    // output.
    // 3. Perform necessary processing on each of these lists.
    List<FaultStatement> allFaultStmts = new ArrayList<FaultStatement>();
    for (SpecStatement s : specs) {
        if (s instanceof FaultStatement) {
            if (!isDisabled((FaultStatement) s)) {
                allFaultStmts.add((FaultStatement) s);
            }
        }
    }
    List<FaultStatement> remainderFS = new ArrayList<FaultStatement>();
    Map<String, List<FaultStatement>> multipleAsymFS = new HashMap<String, List<FaultStatement>>();
    separateFaultStmts(allFaultStmts, remainderFS, multipleAsymFS);
    // processes these stmts, creates faults, and creates associated comm nodes.
    for (String output : multipleAsymFS.keySet()) {
        if (multipleAsymFS.get(output).size() == 1) {
            continue;
        }
        AsymFaultASTBuilder asymBuilder = new AsymFaultASTBuilder(globalLustreNodes, node);
        List<Fault> safetyFaults = asymBuilder.processFaults(multipleAsymFS.get(output));
        mapAsymCompOutputToCommNodeIn = asymBuilder.getMapAsymCompOutputToCommNodeIn();
        mapCommNodeToInputs = asymBuilder.getMapCommNodeToInputs();
        mapCommNodeOutputToConnections = asymBuilder.getMapCommNodeOutputToConnections();
        mapSenderToReceiver = asymBuilder.getMapSenderToReceiver();
        mapCompNameToCommNodes = asymBuilder.getMapCompNameToCommNodes();
        // Create local mapAsymFaultToCompName
        if (node.compInst instanceof ComponentInstance) {
            ComponentInstance comp = node.compInst;
            String name = comp.getName();
            for (Fault safetyFault : safetyFaults) {
                mapAsymFaultToCompName.put(safetyFault, name);
                // Create mapping from fault to associated commNodes.
                // Use mapping from fault to comp name, then map from comp name to
                // comm nodes.
                mapAsymFaultToCommNodes.put(safetyFault, mapCompNameToCommNodes.get(name));
            }
        }
        faults.addAll(safetyFaults);
    }
    // Now process all the rest of the fault stmts.
    for (SpecStatement s : remainderFS) {
        if (s instanceof FaultStatement) {
            FaultStatement fs = (FaultStatement) s;
            FaultASTBuilder builder = new FaultASTBuilder(globalLustreNodes, node);
            // Process fault determines if we have a
            // symmetric or asymmetric fault and builds it accordingly.
            Fault safetyFault = builder.processFault(fs);
            // to main lustre node.
            if (isAsymmetric(fs)) {
                mapAsymCompOutputToCommNodeIn = builder.getMapAsymCompOutputToCommNodeIn();
                mapCommNodeToInputs = builder.getMapCommNodeToInputs();
                mapCommNodeOutputToConnections = builder.getMapCommNodeOutputToConnections();
                mapSenderToReceiver = builder.getMapSenderToReceiver();
                mapCompNameToCommNodes = builder.getMapCompNameToCommNodes();
                // Create local mapAsymFaultToCompName
                if (node.compInst instanceof ComponentInstance) {
                    ComponentInstance comp = node.compInst;
                    String name = comp.getName();
                    mapAsymFaultToCompName.put(safetyFault, name);
                    // Create mapping from fault to associated commNodes.
                    // Use mapping from fault to comp name, then map from comp name to
                    // comm nodes.
                    mapAsymFaultToCommNodes.put(safetyFault, mapCompNameToCommNodes.get(name));
                }
            }
            faults.add(safetyFault);
        }
    }
    return faults;
}