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;
}
