/// <summary>
/// Search program operations implementing the
/// parallelized Lookup search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildParallelLookup(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode target,
IsomorphyInformation isomorphy)
{
bool isNode = target.NodeType == PlanNodeType.Node;
string negativeIndependentNamePrefix = "";
#if RANDOM_LOOKUP_LIST_START
// insert list heads randomization, thus randomized lookup
RandomizeListHeads randomizeListHeads =
new RandomizeListHeads(
RandomizeListHeadsTypes.GraphElements,
target.PatternElement.Name,
isNode);
insertionPoint = insertionPoint.Append(randomizeListHeads);
#endif
// iterate available graph elements
GetCandidateByIterationParallel elementsIteration =
new GetCandidateByIterationParallel(
GetCandidateByIterationType.GraphElements,
target.PatternElement.Name,
isNode,
emitProfiling,
packagePrefixedActionName,
!firstLoopPassed);
firstLoopPassed = true;
SearchProgramOperation continuationPoint =
insertionPoint.Append(elementsIteration);
elementsIteration.NestedOperationsList =
new SearchProgramList(elementsIteration);
insertionPoint = elementsIteration.NestedOperationsList;
// check connectedness of candidate
SearchProgramOperation continuationPointAfterConnectednessCheck;
if(isNode)
{
insertionPoint = decideOnAndInsertCheckConnectednessOfNodeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanNodeNode)target, out continuationPointAfterConnectednessCheck);
}
else
{
insertionPoint = decideOnAndInsertCheckConnectednessOfEdgeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanEdgeNode)target, out continuationPointAfterConnectednessCheck);
}
// check candidate for isomorphy
if(isomorphy.CheckIsMatchedBit)
{
CheckCandidateForIsomorphy checkIsomorphy =
new CheckCandidateForIsomorphy(
target.PatternElement.Name,
isomorphy.PatternElementsToCheckAgainstAsListOfStrings(),
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// accept candidate (write isomorphy information)
if(isomorphy.SetIsMatchedBit)
{
AcceptCandidate acceptCandidate =
new AcceptCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(acceptCandidate);
}
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
// abandon candidate (restore isomorphy information)
if(isomorphy.SetIsMatchedBit)
{ // only if isomorphy information was previously written
AbandonCandidate abandonCandidate =
new AbandonCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(abandonCandidate);
}
// everything nested within candidate iteration built by now -
// continue at the end of the list after candidate iteration
insertionPoint = continuationPoint;
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// parallelized Extend Incoming|Outgoing|IncomingOrOutgoing search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildParallelIncident(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNodeNode source,
SearchPlanEdgeNode target,
IsomorphyInformation isomorphy,
IncidentEdgeType edgeType)
{
#if RANDOM_LOOKUP_LIST_START
// insert list heads randomization, thus randomized extend
RandomizeListHeads randomizeListHeads =
new RandomizeListHeads(
RandomizeListHeadsTypes.IncidentEdges,
target.PatternElement.Name,
source.PatternElement.Name,
getIncoming);
insertionPoint = insertionPoint.Append(randomizeListHeads);
#endif
// iterate available incident edges
SearchPlanNodeNode node = source;
SearchPlanEdgeNode currentEdge = target;
IncidentEdgeType incidentType = edgeType;
SearchProgramOperation continuationPoint;
GetCandidateByIterationParallel incidentIteration;
if(incidentType == IncidentEdgeType.Incoming || incidentType == IncidentEdgeType.Outgoing)
{
incidentIteration = new GetCandidateByIterationParallel(
GetCandidateByIterationType.IncidentEdges,
currentEdge.PatternElement.Name,
node.PatternElement.Name,
incidentType,
emitProfiling,
packagePrefixedActionName,
!firstLoopPassed);
firstLoopPassed = true;
incidentIteration.NestedOperationsList = new SearchProgramList(incidentIteration);
continuationPoint = insertionPoint.Append(incidentIteration);
insertionPoint = incidentIteration.NestedOperationsList;
}
else // IncidentEdgeType.IncomingOrOutgoing
{
if(currentEdge.PatternEdgeSource == currentEdge.PatternEdgeTarget)
{
// reflexive edge without direction iteration as we don't want 2 matches
incidentIteration = new GetCandidateByIterationParallel(
GetCandidateByIterationType.IncidentEdges,
currentEdge.PatternElement.Name,
node.PatternElement.Name,
IncidentEdgeType.Incoming,
emitProfiling,
packagePrefixedActionName,
!firstLoopPassed);
firstLoopPassed = true;
incidentIteration.NestedOperationsList = new SearchProgramList(incidentIteration);
continuationPoint = insertionPoint.Append(incidentIteration);
insertionPoint = incidentIteration.NestedOperationsList;
}
else
{
incidentIteration = new GetCandidateByIterationParallel(
GetCandidateByIterationType.IncidentEdges,
currentEdge.PatternElement.Name,
node.PatternElement.Name,
IncidentEdgeType.IncomingOrOutgoing,
emitProfiling,
packagePrefixedActionName,
!firstLoopPassed);
firstLoopPassed = true;
incidentIteration.NestedOperationsList = new SearchProgramList(incidentIteration);
continuationPoint = insertionPoint.Append(incidentIteration);
insertionPoint = incidentIteration.NestedOperationsList;
}
}
// check type of candidate
insertionPoint = decideOnAndInsertCheckType(insertionPoint, target);
// check connectedness of candidate
SearchProgramOperation continuationPointOfConnectednessCheck;
insertionPoint = decideOnAndInsertCheckConnectednessOfIncidentEdgeFromNode(
insertionPoint, target, source, edgeType == IncidentEdgeType.Incoming,
out continuationPointOfConnectednessCheck);
// check candidate for isomorphy
string negativeIndependentNamePrefix = "";
if(isomorphy.CheckIsMatchedBit)
{
CheckCandidateForIsomorphy checkIsomorphy =
new CheckCandidateForIsomorphy(
target.PatternElement.Name,
isomorphy.PatternElementsToCheckAgainstAsListOfStrings(),
negativeIndependentNamePrefix,
false,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// accept candidate (write isomorphy information)
if(isomorphy.SetIsMatchedBit)
{
AcceptCandidate acceptCandidate =
new AcceptCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
false,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(acceptCandidate);
}
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
// abandon candidate (restore isomorphy information)
if(isomorphy.SetIsMatchedBit)
{ // only if isomorphy information was previously written
AbandonCandidate abandonCandidate =
new AbandonCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
false,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(abandonCandidate);
}
// everything nested within incident iteration built by now -
// continue at the end of the list after incident edges iteration
insertionPoint = continuationPoint;
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// Lookup search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildLookup(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode target,
IsomorphyInformation isomorphy)
{
bool isNode = target.NodeType == PlanNodeType.Node;
string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
// decide on and insert operation determining type of candidate
SearchProgramOperation continuationPointAfterTypeIteration;
SearchProgramOperation insertionPointAfterTypeIteration =
decideOnAndInsertGetType(insertionPoint, target,
out continuationPointAfterTypeIteration);
insertionPoint = insertionPointAfterTypeIteration;
#if RANDOM_LOOKUP_LIST_START
// insert list heads randomization, thus randomized lookup
RandomizeListHeads randomizeListHeads =
new RandomizeListHeads(
RandomizeListHeadsTypes.GraphElements,
target.PatternElement.Name,
isNode);
insertionPoint = insertionPoint.Append(randomizeListHeads);
#endif
// iterate available graph elements
GetCandidateByIteration elementsIteration =
new GetCandidateByIteration(
GetCandidateByIterationType.GraphElements,
target.PatternElement.Name,
isNode,
parallelized,
emitProfiling,
packagePrefixedActionName,
!firstLoopPassed);
firstLoopPassed = true;
SearchProgramOperation continuationPoint =
insertionPoint.Append(elementsIteration);
elementsIteration.NestedOperationsList =
new SearchProgramList(elementsIteration);
insertionPoint = elementsIteration.NestedOperationsList;
// check connectedness of candidate
SearchProgramOperation continuationPointAfterConnectednessCheck;
if (isNode)
{
insertionPoint = decideOnAndInsertCheckConnectednessOfNodeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanNodeNode)target, out continuationPointAfterConnectednessCheck);
}
else
{
insertionPoint = decideOnAndInsertCheckConnectednessOfEdgeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanEdgeNode)target, out continuationPointAfterConnectednessCheck);
}
// check candidate for isomorphy
if (isomorphy.CheckIsMatchedBit)
{
CheckCandidateForIsomorphy checkIsomorphy =
new CheckCandidateForIsomorphy(
target.PatternElement.Name,
isomorphy.PatternElementsToCheckAgainstAsListOfStrings(),
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// check candidate for global isomorphy
if (programType==SearchProgramType.Subpattern
|| programType==SearchProgramType.AlternativeCase
|| programType==SearchProgramType.Iterated)
{
if(!isomorphy.TotallyHomomorph)
{
CheckCandidateForIsomorphyGlobal checkIsomorphy =
new CheckCandidateForIsomorphyGlobal(
target.PatternElement.Name,
isomorphy.GloballyHomomorphPatternElementsAsListOfStrings(),
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
}
// check candidate for pattern path isomorphy
if (patternGraphWithNestingPatterns.Peek().isPatternGraphOnPathFromEnclosingPatternpath)
{
CheckCandidateForIsomorphyPatternPath checkIsomorphy =
new CheckCandidateForIsomorphyPatternPath(
target.PatternElement.Name,
isNode,
patternGraphWithNestingPatterns.Peek().isPatternpathLocked,
getCurrentLastMatchAtPreviousNestingLevel());
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// accept candidate (write isomorphy information)
if (isomorphy.SetIsMatchedBit)
{
AcceptCandidate acceptCandidate =
new AcceptCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(acceptCandidate);
}
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
// abandon candidate (restore isomorphy information)
if (isomorphy.SetIsMatchedBit)
{ // only if isomorphy information was previously written
AbandonCandidate abandonCandidate =
new AbandonCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(abandonCandidate);
}
// everything nested within candidate iteration built by now -
// continue at the end of the list at type iteration nesting level
insertionPoint = continuationPoint;
// everything nested within type iteration built by now
// continue at the end of the list handed in
if (insertionPointAfterTypeIteration != continuationPointAfterTypeIteration)
{
// if type was drawn then the if is not entered (insertion point==continuation point)
// thus we continue at the continuation point of the candidate iteration
// otherwise if type was iterated
// we continue at the continuation point of the type iteration
insertionPoint = continuationPointAfterTypeIteration;
}
return insertionPoint;
}