private bool _HasConflictingArrayAccesses(TLoopStatementSyntax loopStatement, string loopIndex, Code code, VariableAccesses variableAccesses) { var optimized = OptimizationRunner.Optimize(code); code = optimized.Code; variableAccesses = optimized.Changed ? VariableAccesses.Collect(code) : variableAccesses; var cfg = ControlFlowGraphFactory.Create(code, true); var callGraph = CallGraphFactory.Create(cfg, _methods); var calledMethods = callGraph.Methods.Select(methodName => _methods[methodName]).ToImmutableList(); var aliasAnalysis = AliasAnalysis.Analyze(cfg, callGraph, _methods.Values, _GetAliasesAtLoopEntry(loopStatement, variableAccesses)); return(ArrayAccessVerifier.HasConflictingAccesses(loopIndex, cfg, aliasAnalysis, callGraph, calledMethods)); }
/// <summary> /// Checks that there are no conflicting read and write accesses to arrays. /// </summary> /// <param name="loopIndex">The loop index of the loop that is subject for parallelization.</param> /// <param name="controlFlowGraph">The control flow graph of the body of the loop.</param> /// <param name="aliasAnalysis">A prelimary applied alias analysis already fed with possible aliases outside of the loop.</param> /// <param name="callGraph">The graph identifying the calls of methods for interprocedural analysis.</param> /// <param name="procedures">The control flow graphs of the invoked methods.</param> /// <returns><code>True</code> if there are no conflicting accesses to arrays.</returns> public static bool HasConflictingAccesses(string loopIndex, ControlFlowGraph controlFlowGraph, AliasAnalysis aliasAnalysis, CallGraph callGraph, IEnumerable <ControlFlowGraph> procedures) { var loopDependenceAnalysis = LoopDependenceAnalysis.Analyze(controlFlowGraph, loopIndex, callGraph, procedures); var arrayAccesses = ArrayAccessCollector.Collect(new[] { controlFlowGraph }.Concat(procedures).SelectMany(graph => graph.Nodes)); var verifier = new ArrayAccessVerifier(loopDependenceAnalysis, aliasAnalysis, arrayAccesses); return(verifier._ContainsLoopCarriedDependencies()); }
/// <summary> /// Checks that there are no conflicting read and write accesses to arrays. /// </summary> /// <param name="loopIndex">The loop index of the loop that is subject for parallelization.</param> /// <param name="controlFlowGraph">The control flow graph of the body of the loop.</param> /// <param name="aliasAnalysis">A prelimary applied alias analysis already fed with possible aliases outside of the loop.</param> /// <returns><code>True</code> if there are no conflicting accesses to arrays.</returns> public static bool HasConflictingAccesses(string loopIndex, ControlFlowGraph controlFlowGraph, AliasAnalysis aliasAnalysis) { var loopDependenceAnalysis = LoopDependenceAnalysis.Analyze(controlFlowGraph, loopIndex); var arrayAccesses = ArrayAccessCollector.Collect(controlFlowGraph); var verifier = new ArrayAccessVerifier(loopDependenceAnalysis, aliasAnalysis, arrayAccesses); return(verifier._ContainsLoopCarriedDependencies()); }
private ArrayAccessVerifier(LoopDependenceAnalysis loopDependenceAnalysis, AliasAnalysis aliasAnalysis, ISet <ArrayAccess> arrayAccesses) { _loopDependenceAnalysis = loopDependenceAnalysis; _aliasAnalysis = aliasAnalysis; _arrayAccesses = arrayAccesses; }
/// <summary> /// Creates an expression equality which makes use of flow information and aliases. /// </summary> /// <param name="aNode">The control flow graph node where the first expression is located.</param> /// <param name="bNode">The control flow graph node where the second expression is located.</param> /// <param name="aliases">The aliases collected within the control flow graph.</param> public ExpressionEquality(FlowNode aNode, FlowNode bNode, AliasAnalysis aliases) { _aNode = aNode; _bNode = bNode; _aliases = aliases; }