/// <summary> /// move outwards from starting point on until operation to continue at is found /// appending restore isomorphy at insertion point for isomorphy written on the way /// returns operation to continue at /// </summary> private static SearchProgramOperation MoveOutwardsAppendingRemoveIsomorphy( SearchProgramOperation startingPoint, ref SearchProgramOperation insertionPoint, string[] neededElementsForCheckOperation, SearchProgramOperation outermostOperation, SearchProgram topLevelSearchProgram) { // currently focused operation on our way outwards SearchProgramOperation op = startingPoint; // move outwards until operation to continue at is found bool creationPointOfDominatingElementFound = false; bool iterationReached = false; do { op = op.Previous; // insert code to clean up isomorphy information written by candidate acceptance // in between the operation to continue and the check operation if (op is AcceptCandidate) { AcceptCandidate writeIsomorphy = op as AcceptCandidate; AbandonCandidate restoreIsomorphy = new AbandonCandidate( writeIsomorphy.PatternElementName, writeIsomorphy.NegativeIndependentNamePrefix, writeIsomorphy.IsNode, writeIsomorphy.NeverAboveMaxIsoSpace, writeIsomorphy.Parallel, writeIsomorphy.LockForAllThreads); insertionPoint = insertionPoint.Append(restoreIsomorphy); } // insert code to clean up isomorphy information written by global candidate acceptance // in between the operation to continue and the check operation if (op is AcceptCandidateGlobal) { AcceptCandidateGlobal writeIsomorphy = op as AcceptCandidateGlobal; AbandonCandidateGlobal removeIsomorphy = new AbandonCandidateGlobal( writeIsomorphy.PatternElementName, writeIsomorphy.NegativeIndependentNamePrefix, writeIsomorphy.IsNode, writeIsomorphy.NeverAboveMaxIsoSpace, writeIsomorphy.Parallel); insertionPoint = insertionPoint.Append(removeIsomorphy); } // insert code to clean up isomorphy information written by patternpath candidate acceptance // in between the operation to continue and the check operation if (op is AcceptCandidatePatternpath) { AcceptCandidatePatternpath writeIsomorphy = op as AcceptCandidatePatternpath; AbandonCandidatePatternpath removeIsomorphy = new AbandonCandidatePatternpath( writeIsomorphy.PatternElementName, writeIsomorphy.NegativeIndependentNamePrefix, writeIsomorphy.IsNode); insertionPoint = insertionPoint.Append(removeIsomorphy); } // insert code to remove iterated pattern acceptance if (op is AcceptIterated) { AcceptIterated acceptIterated = op as AcceptIterated; AbandonIterated abandonIterated = new AbandonIterated(); insertionPoint = insertionPoint.Append(abandonIterated); } // insert code to undo subpattern matching initialization if we leave the subpattern matching method if (op is InitializeSubpatternMatching) { InitializeSubpatternMatching initialize = op as InitializeSubpatternMatching; FinalizeSubpatternMatching finalize = new FinalizeSubpatternMatching(initialize.Type); insertionPoint = insertionPoint.Append(finalize); } // insert code to undo negative/independent matching initialization if we leave the negative/independent matching method if (op is InitializeNegativeIndependentMatching) { InitializeNegativeIndependentMatching initialize = op as InitializeNegativeIndependentMatching; FinalizeNegativeIndependentMatching finalize = new FinalizeNegativeIndependentMatching(initialize.NeverAboveMaxIsoSpace, initialize.Parallel); insertionPoint = insertionPoint.Append(finalize); } // determine operation to continue at // found by looking at the graph elements // the check operation depends on / is dominated by // its the first element iteration on our way outwards the search program // after or at the point of a get element operation // of some dominating element the check depends on // (or the outermost operation if no iteration is found until it is reached) if (op is GetCandidate || op is BothDirectionsIteration) { if (creationPointOfDominatingElementFound == false) { if (neededElementsForCheckOperation != null) { foreach (string dominating in neededElementsForCheckOperation) { GetCandidate getCandidate = op as GetCandidate; BothDirectionsIteration bothDirections = op as BothDirectionsIteration; if (getCandidate != null && getCandidate.PatternElementName == dominating || bothDirections != null && bothDirections.PatternElementName == dominating) { creationPointOfDominatingElementFound = true; iterationReached = false; break; } } } else { // needed elements == null means everything fits, // take first element iteration on our way outwards the search program // (or the outermost operation if no iteration is found until it is reached) creationPointOfDominatingElementFound = true; iterationReached = false; } } if (op is GetCandidateByIteration || op is GetCandidateByIterationParallel || op is BothDirectionsIteration) { iterationReached = true; } } }while(!(creationPointOfDominatingElementFound && iterationReached) && op != outermostOperation); return(op); }
/// <summary> /// Search program operations implementing the /// ActionPreset search plan operation /// are created and inserted into search program /// </summary> private SearchProgramOperation buildActionPreset( SearchProgramOperation insertionPoint, int currentOperationIndex, SearchPlanNode target, IsomorphyInformation isomorphy) { bool isNode = target.NodeType == PlanNodeType.Node; string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek()); Debug.Assert(negativeIndependentNamePrefix == "", "Top-level maybe preset in negative/independent search plan"); Debug.Assert(programType != SearchProgramType.Subpattern, "Maybe preset in subpattern"); Debug.Assert(programType != SearchProgramType.AlternativeCase, "Maybe preset in alternative"); Debug.Assert(programType != SearchProgramType.Iterated, "Maybe preset in iterated"); // get candidate from inputs GetCandidateByDrawing fromInputs = new GetCandidateByDrawing( GetCandidateByDrawingType.FromInputs, target.PatternElement.Name, isNode); insertionPoint = insertionPoint.Append(fromInputs); // check type of candidate insertionPoint = decideOnAndInsertCheckType(insertionPoint, target); // 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); } return insertionPoint; }
/// <summary> /// move outwards from starting point on until operation to continue at is found /// appending restore isomorphy at insertion point for isomorphy written on the way /// returns operation to continue at /// </summary> private SearchProgramOperation MoveOutwardsAppendingRemoveIsomorphy( SearchProgramOperation startingPoint, ref SearchProgramOperation insertionPoint, string[] neededElementsForCheckOperation, SearchProgramOperation outermostOperation, SearchProgram topLevelSearchProgram) { // currently focused operation on our way outwards SearchProgramOperation op = startingPoint; // move outwards until operation to continue at is found bool creationPointOfDominatingElementFound = false; bool iterationReached = false; do { op = op.Previous; // insert code to clean up isomorphy information written by candidate acceptance // in between the operation to continue and the check operation if (op is AcceptCandidate) { AcceptCandidate writeIsomorphy = op as AcceptCandidate; AbandonCandidate restoreIsomorphy = new AbandonCandidate( writeIsomorphy.PatternElementName, writeIsomorphy.NegativeIndependentNamePrefix, writeIsomorphy.IsNode, writeIsomorphy.NeverAboveMaxIsoSpace, writeIsomorphy.Parallel, writeIsomorphy.LockForAllThreads); insertionPoint = insertionPoint.Append(restoreIsomorphy); } // insert code to clean up isomorphy information written by global candidate acceptance // in between the operation to continue and the check operation if (op is AcceptCandidateGlobal) { AcceptCandidateGlobal writeIsomorphy = op as AcceptCandidateGlobal; AbandonCandidateGlobal removeIsomorphy = new AbandonCandidateGlobal( writeIsomorphy.PatternElementName, writeIsomorphy.NegativeIndependentNamePrefix, writeIsomorphy.IsNode, writeIsomorphy.NeverAboveMaxIsoSpace, writeIsomorphy.Parallel); insertionPoint = insertionPoint.Append(removeIsomorphy); } // insert code to clean up isomorphy information written by patternpath candidate acceptance // in between the operation to continue and the check operation if (op is AcceptCandidatePatternpath) { AcceptCandidatePatternpath writeIsomorphy = op as AcceptCandidatePatternpath; AbandonCandidatePatternpath removeIsomorphy = new AbandonCandidatePatternpath( writeIsomorphy.PatternElementName, writeIsomorphy.NegativeIndependentNamePrefix, writeIsomorphy.IsNode); insertionPoint = insertionPoint.Append(removeIsomorphy); } // insert code to remove iterated pattern acceptance if (op is AcceptIterated) { AcceptIterated acceptIterated = op as AcceptIterated; AbandonIterated abandonIterated = new AbandonIterated(); insertionPoint = insertionPoint.Append(abandonIterated); } // insert code to undo subpattern matching initialization if we leave the subpattern matching method if (op is InitializeSubpatternMatching) { InitializeSubpatternMatching initialize = op as InitializeSubpatternMatching; FinalizeSubpatternMatching finalize = new FinalizeSubpatternMatching(initialize.Type); insertionPoint = insertionPoint.Append(finalize); } // insert code to undo negative/independent matching initialization if we leave the negative/independent matching method if (op is InitializeNegativeIndependentMatching) { InitializeNegativeIndependentMatching initialize = op as InitializeNegativeIndependentMatching; FinalizeNegativeIndependentMatching finalize = new FinalizeNegativeIndependentMatching(initialize.NeverAboveMaxIsoSpace, initialize.Parallel); insertionPoint = insertionPoint.Append(finalize); } // determine operation to continue at // found by looking at the graph elements // the check operation depends on / is dominated by // its the first element iteration on our way outwards the search program // after or at the point of a get element operation // of some dominating element the check depends on // (or the outermost operation if no iteration is found until it is reached) if (op is GetCandidate || op is BothDirectionsIteration) { if (creationPointOfDominatingElementFound == false) { if (neededElementsForCheckOperation != null) { foreach (string dominating in neededElementsForCheckOperation) { GetCandidate getCandidate = op as GetCandidate; BothDirectionsIteration bothDirections = op as BothDirectionsIteration; if (getCandidate!=null && getCandidate.PatternElementName == dominating || bothDirections!=null && bothDirections.PatternElementName == dominating) { creationPointOfDominatingElementFound = true; iterationReached = false; break; } } } else { // needed elements == null means everything fits, // take first element iteration on our way outwards the search program // (or the outermost operation if no iteration is found until it is reached) creationPointOfDominatingElementFound = true; iterationReached = false; } } if (op is GetCandidateByIteration || op is GetCandidateByIterationParallel || op is BothDirectionsIteration) { iterationReached = true; } } } while (!(creationPointOfDominatingElementFound && iterationReached) && op != outermostOperation); return op; }
/// <summary> /// Search program operations implementing the /// parallelized PickFromIndex search plan operation /// are created and inserted into search program /// </summary> private SearchProgramOperation buildParallelPickFromIndex( SearchProgramOperation insertionPoint, int currentOperationIndex, SearchPlanNode target, IndexAccess index, IsomorphyInformation isomorphy) { bool isNode = target.NodeType == PlanNodeType.Node; string negativeIndependentNamePrefix = ""; string iterationType = TypesHelper.TypeName(index.Index is AttributeIndexDescription ? ((AttributeIndexDescription)index.Index).GraphElementType : ((IncidenceCountIndexDescription)index.Index).StartNodeType); string indexSetType = NamesOfEntities.IndexSetType(model.ModelName); // iterate available index elements GetCandidateByIterationParallel elementsIteration; if(index is IndexAccessEquality) { IndexAccessEquality indexEquality = (IndexAccessEquality)index; SourceBuilder equalityExpression = new SourceBuilder(); indexEquality.Expr.Emit(equalityExpression); elementsIteration = new GetCandidateByIterationParallel( GetCandidateByIterationType.IndexElements, target.PatternElement.Name, index.Index.Name, iterationType, indexSetType, IndexAccessType.Equality, equalityExpression.ToString(), isNode, emitProfiling, packagePrefixedActionName, !firstLoopPassed); } else if(index is IndexAccessAscending) { IndexAccessAscending indexAscending = (IndexAccessAscending)index; SourceBuilder fromExpression = new SourceBuilder(); if(indexAscending.From != null) indexAscending.From.Emit(fromExpression); SourceBuilder toExpression = new SourceBuilder(); if(indexAscending.To != null) indexAscending.To.Emit(toExpression); elementsIteration = new GetCandidateByIterationParallel( GetCandidateByIterationType.IndexElements, target.PatternElement.Name, index.Index.Name, iterationType, indexSetType, IndexAccessType.Ascending, indexAscending.From != null ? fromExpression.ToString() : null, indexAscending.IncludingFrom, indexAscending.To != null ? toExpression.ToString() : null, indexAscending.IncludingTo, isNode, emitProfiling, packagePrefixedActionName, !firstLoopPassed); } else //if(index is IndexAccessDescending) { IndexAccessDescending indexDescending = (IndexAccessDescending)index; SourceBuilder fromExpression = new SourceBuilder(); if(indexDescending.From != null) indexDescending.From.Emit(fromExpression); SourceBuilder toExpression = new SourceBuilder(); if(indexDescending.To != null) indexDescending.To.Emit(toExpression); elementsIteration = new GetCandidateByIterationParallel( GetCandidateByIterationType.IndexElements, target.PatternElement.Name, index.Index.Name, iterationType, indexSetType, IndexAccessType.Descending, indexDescending.From != null ? fromExpression.ToString() : null, indexDescending.IncludingFrom, indexDescending.To != null ? toExpression.ToString() : null, indexDescending.IncludingTo, isNode, emitProfiling, packagePrefixedActionName, !firstLoopPassed); } firstLoopPassed = true; SearchProgramOperation continuationPoint = insertionPoint.Append(elementsIteration); elementsIteration.NestedOperationsList = new SearchProgramList(elementsIteration); insertionPoint = elementsIteration.NestedOperationsList; // check type of candidate insertionPoint = decideOnAndInsertCheckType(insertionPoint, target); // 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 storage 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 /// 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 PickFromStorageDependent search plan operation /// are created and inserted into search program /// </summary> private SearchProgramOperation buildParallelPickFromStorageDependent( SearchProgramOperation insertionPoint, int currentOperationIndex, SearchPlanNode source, SearchPlanNode target, StorageAccess storage, IsomorphyInformation isomorphy) { bool isNode = target.NodeType == PlanNodeType.Node; bool isDict = storage.Attribute.Attribute.Kind == AttributeKind.SetAttr || storage.Attribute.Attribute.Kind == AttributeKind.MapAttr; string negativeIndependentNamePrefix = ""; // iterate available storage elements string iterationType; if(isDict) if(storage.Attribute.Attribute.Kind == AttributeKind.SetAttr) { iterationType = "System.Collections.Generic.KeyValuePair<" + TypesHelper.XgrsTypeToCSharpType(storage.Attribute.Attribute.ValueType.GetKindName(), model) + "," + "de.unika.ipd.grGen.libGr.SetValueType" + ">"; } else { iterationType = "System.Collections.Generic.KeyValuePair<" + TypesHelper.XgrsTypeToCSharpType(storage.Attribute.Attribute.KeyType.GetKindName(), model) + "," + TypesHelper.XgrsTypeToCSharpType(storage.Attribute.Attribute.ValueType.GetKindName(), model) + ">"; } else iterationType = TypesHelper.XgrsTypeToCSharpType(storage.Attribute.Attribute.ValueType.GetKindName(), model); GetCandidateByIterationParallel elementsIteration = new GetCandidateByIterationParallel( GetCandidateByIterationType.StorageAttributeElements, target.PatternElement.Name, source.PatternElement.Name, source.PatternElement.typeName, storage.Attribute.Attribute.Name, iterationType, isDict, isNode, emitProfiling, packagePrefixedActionName, !firstLoopPassed); firstLoopPassed = true; SearchProgramOperation continuationPoint = insertionPoint.Append(elementsIteration); elementsIteration.NestedOperationsList = new SearchProgramList(elementsIteration); insertionPoint = elementsIteration.NestedOperationsList; // check type of candidate insertionPoint = decideOnAndInsertCheckType(insertionPoint, target); // 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 storage iteration nesting level insertionPoint = continuationPoint; return insertionPoint; }
/// <summary> /// Search program operations implementing the /// MapWithStorageDependent search plan operation /// are created and inserted into search program /// </summary> private SearchProgramOperation buildMapWithStorageDependent( SearchProgramOperation insertionPoint, int currentOperationIndex, SearchPlanNode source, SearchPlanNode target, StorageAccess storage, StorageAccessIndex index, IsomorphyInformation isomorphy) { bool isNode = target.NodeType == PlanNodeType.Node; string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek()); // storage muss ein container typ nach graph element sein, index muss ein elementarer typ sein if(storage.Variable != null && index.Variable != null) ;// das kann hier nicht auftreten; if(storage.Variable != null && index.GlobalVariable != null) ;// das kann hier nicht auftreten; if(storage.Variable != null && index.Attribute != null) ;// neu if(storage.Variable != null && index.GraphElement != null) ;// alt, siehe unten if(storage.GlobalVariable != null && index.Variable != null) ;// das kann hier nicht auftreten; if(storage.GlobalVariable != null && index.GlobalVariable != null) ;// das kann hier nicht auftreten; if(storage.GlobalVariable != null && index.Attribute != null) ;// neu if(storage.GlobalVariable != null && index.GraphElement != null) ;// neu if(storage.Attribute != null && index.Variable != null) ;// neu if(storage.Attribute != null && index.GlobalVariable != null) ;// neu if(storage.Attribute != null && index.Attribute != null) ;// kann nicht auftreten, 2 abhängigkeiten if(storage.Attribute != null && index.GraphElement != null) ;// kann nicht auftreten, 2 anhängigkeiten // get candidate from storage-map, only creates variable to hold it, get is fused with check for map membership GetCandidateByDrawing elementFromStorage = new GetCandidateByDrawing( GetCandidateByDrawingType.MapWithStorage, target.PatternElement.Name, source.PatternElement.Name, storage.Variable.Name, TypesHelper.GetStorageValueTypeName(storage.Variable.type), isNode); insertionPoint = insertionPoint.Append(elementFromStorage); // check existence of candidate in storage map CheckCandidateMapWithStorage checkElementInStorage = new CheckCandidateMapWithStorage( target.PatternElement.Name, source.PatternElement.Name, storage.Variable.Name, TypesHelper.GetStorageKeyTypeName(storage.Variable.type), isNode); insertionPoint = insertionPoint.Append(checkElementInStorage); // check type of candidate insertionPoint = decideOnAndInsertCheckType(insertionPoint, target); // check connectedness of candidate SearchProgramOperation continuationPointAfterConnectednessCheck; if(isNode) { insertionPoint = decideOnAndInsertCheckConnectednessOfNodeFromLookupOrPickOrMap( insertionPoint, (SearchPlanNodeNode)target, out continuationPointAfterConnectednessCheck); } else { insertionPoint = decideOnAndInsertCheckConnectednessOfEdgeFromLookupOrPickOrMap( insertionPoint, (SearchPlanEdgeNode)target, out continuationPointAfterConnectednessCheck); } if(continuationPointAfterConnectednessCheck == insertionPoint) continuationPointAfterConnectednessCheck = null; // 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); } if(continuationPointAfterConnectednessCheck != null) insertionPoint = continuationPointAfterConnectednessCheck; return insertionPoint; }
/// <summary> /// Search program operations implementing the /// Implicit Source|Target|SourceOrTarget search plan operation /// are created and inserted into search program /// </summary> private SearchProgramOperation buildImplicit( SearchProgramOperation insertionPoint, int currentOperationIndex, SearchPlanEdgeNode source, SearchPlanNodeNode target, IsomorphyInformation isomorphy, ImplicitNodeType nodeType) { // get candidate = demanded node from edge SearchProgramOperation continuationPoint; insertionPoint = insertImplicitNodeFromEdge(insertionPoint, source, target, nodeType, out continuationPoint); if (continuationPoint == insertionPoint) continuationPoint = null; // check type of candidate insertionPoint = decideOnAndInsertCheckType(insertionPoint, target); // check connectedness of candidate SearchProgramOperation continuationPointAfterConnectednessCheck; SearchPlanNodeNode otherNodeOfOriginatingEdge = null; if (nodeType == ImplicitNodeType.Source) otherNodeOfOriginatingEdge = source.PatternEdgeTarget; if (nodeType == ImplicitNodeType.Target) otherNodeOfOriginatingEdge = source.PatternEdgeSource; if (source.PatternEdgeTarget == source.PatternEdgeSource) // reflexive sign needed in unfixed direction case, too otherNodeOfOriginatingEdge = source.PatternEdgeSource; insertionPoint = decideOnAndInsertCheckConnectednessOfImplicitNodeFromEdge( insertionPoint, target, source, otherNodeOfOriginatingEdge, out continuationPointAfterConnectednessCheck); if (continuationPoint == null && continuationPointAfterConnectednessCheck != insertionPoint) continuationPoint = continuationPointAfterConnectednessCheck; // check candidate for isomorphy string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek()); if (isomorphy.CheckIsMatchedBit) { CheckCandidateForIsomorphy checkIsomorphy = new CheckCandidateForIsomorphy( target.PatternElement.Name, isomorphy.PatternElementsToCheckAgainstAsListOfStrings(), negativeIndependentNamePrefix, true, 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(), true, isoSpaceNeverAboveMaxIsoSpace, isomorphy.Parallel); insertionPoint = insertionPoint.Append(checkIsomorphy); } } // check candidate for pattern path isomorphy if(patternGraphWithNestingPatterns.Peek().isPatternGraphOnPathFromEnclosingPatternpath) { CheckCandidateForIsomorphyPatternPath checkIsomorphy = new CheckCandidateForIsomorphyPatternPath( target.PatternElement.Name, true, patternGraphWithNestingPatterns.Peek().isPatternpathLocked, getCurrentLastMatchAtPreviousNestingLevel()); insertionPoint = insertionPoint.Append(checkIsomorphy); } // accept candidate (write isomorphy information) if (isomorphy.SetIsMatchedBit) { AcceptCandidate acceptCandidate = new AcceptCandidate( target.PatternElement.Name, negativeIndependentNamePrefix, true, 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, true, isoSpaceNeverAboveMaxIsoSpace, isomorphy.Parallel, isomorphy.LockForAllThreads); insertionPoint = insertionPoint.Append(abandonCandidate); } if (continuationPoint != null) insertionPoint = continuationPoint; return insertionPoint; }
/// <summary> /// Search program operations implementing the /// Cast search plan operation /// are created and inserted into search program /// </summary> private SearchProgramOperation buildCast( SearchProgramOperation insertionPoint, int currentOperationIndex, SearchPlanNode source, SearchPlanNode target, IsomorphyInformation isomorphy) { bool isNode = target.NodeType == PlanNodeType.Node; string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek()); // get candidate from other element (the cast is simply the following type check) GetCandidateByDrawing fromOtherElementForCast = new GetCandidateByDrawing( GetCandidateByDrawingType.FromOtherElementForCast, target.PatternElement.Name, source.PatternElement.Name, isNode); insertionPoint = insertionPoint.Append(fromOtherElementForCast); // check type of candidate insertionPoint = decideOnAndInsertCheckType(insertionPoint, target); // 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); } return insertionPoint; }
/// <summary> /// Search program operations implementing the /// PickByUnique or PickByUniqueDependent search plan operation /// are created and inserted into search program /// </summary> private SearchProgramOperation buildPickByUnique( SearchProgramOperation insertionPoint, int currentOperationIndex, SearchPlanNode target, UniqueLookup uniqueLookup, IsomorphyInformation isomorphy) { bool isNode = target.NodeType == PlanNodeType.Node; string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek()); SourceBuilder expression = new SourceBuilder(); uniqueLookup.Expr.Emit(expression); // get candidate from unique index, only creates variable to hold it, get is fused with check for index membership GetCandidateByDrawing elementByUnique = new GetCandidateByDrawing( GetCandidateByDrawingType.MapByUnique, target.PatternElement.Name, expression.ToString(), isNode); insertionPoint = insertionPoint.Append(elementByUnique); // check existence of candidate in unique map CheckCandidateMapByUnique checkElementInUniqueMap = new CheckCandidateMapByUnique( target.PatternElement.Name, isNode); insertionPoint = insertionPoint.Append(checkElementInUniqueMap); // check type of candidate insertionPoint = decideOnAndInsertCheckType(insertionPoint, target); // check connectedness of candidate SearchProgramOperation continuationPointAfterConnectednessCheck; if(isNode) { insertionPoint = decideOnAndInsertCheckConnectednessOfNodeFromLookupOrPickOrMap( insertionPoint, (SearchPlanNodeNode)target, out continuationPointAfterConnectednessCheck); } else { insertionPoint = decideOnAndInsertCheckConnectednessOfEdgeFromLookupOrPickOrMap( insertionPoint, (SearchPlanEdgeNode)target, out continuationPointAfterConnectednessCheck); } if(continuationPointAfterConnectednessCheck == insertionPoint) continuationPointAfterConnectednessCheck = null; // 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); } if(continuationPointAfterConnectednessCheck != null) insertionPoint = continuationPointAfterConnectednessCheck; return insertionPoint; }
/// <summary> /// Search program operations implementing the /// PickFromStorage search plan operation /// are created and inserted into search program /// </summary> private SearchProgramOperation buildPickFromStorage( SearchProgramOperation insertionPoint, int currentOperationIndex, SearchPlanNode target, StorageAccess storage, IsomorphyInformation isomorphy) { bool isNode = target.NodeType == PlanNodeType.Node; bool isDict = TypesHelper.DotNetTypeToXgrsType(storage.Variable.type).StartsWith("set") || TypesHelper.DotNetTypeToXgrsType(storage.Variable.type).StartsWith("map"); string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek()); // iterate available storage elements string iterationType; if(isDict) iterationType = "System.Collections.Generic.KeyValuePair<" + TypesHelper.GetStorageKeyTypeName(storage.Variable.type) + "," + TypesHelper.GetStorageValueTypeName(storage.Variable.type) + ">"; else iterationType = TypesHelper.GetStorageKeyTypeName(storage.Variable.type); GetCandidateByIteration elementsIteration = new GetCandidateByIteration( GetCandidateByIterationType.StorageElements, target.PatternElement.Name, storage.Variable.Name, iterationType, isDict, isNode, parallelized, emitProfiling, packagePrefixedActionName, !firstLoopPassed); firstLoopPassed = true; SearchProgramOperation continuationPoint = insertionPoint.Append(elementsIteration); elementsIteration.NestedOperationsList = new SearchProgramList(elementsIteration); insertionPoint = elementsIteration.NestedOperationsList; // check type of candidate insertionPoint = decideOnAndInsertCheckType(insertionPoint, target); // 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 after storage iteration nesting level insertionPoint = continuationPoint; if(storage.Variable != null) ; // alt, siehe oben if(storage.GlobalVariable != null) ; // neu -- wenn es ein container-typ ist iterieren, wenn es ein elementarer typ ist eine einfache zuweisung -- und kein != null handling if(storage.Attribute != null) ; // das kann hier nicht auftreten 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; }
/// <summary> /// Search program operations implementing the /// NegIdptPreset search plan operation /// are created and inserted into search program /// </summary> private SearchProgramOperation buildNegIdptPreset( SearchProgramOperation insertionPoint, int currentOperationIndex, SearchPlanNode target, IsomorphyInformation isomorphy) { bool isNode = target.NodeType == PlanNodeType.Node; string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek()); Debug.Assert(negativeIndependentNamePrefix != "", "Negative/Independent preset in top-level search plan"); // an inlined independet preset is differently named, must be assigned first if(target.PatternElement.PresetBecauseOfIndependentInlining) { // get candidate from other element (the cast is simply the following type check) GetCandidateByDrawing inlinedIndependentPreset = new GetCandidateByDrawing( GetCandidateByDrawingType.FromOtherElementForAssign, target.PatternElement.Name, target.PatternElement.Name + "_inlined_" + patternGraphWithNestingPatterns.Peek().Name, isNode); insertionPoint = insertionPoint.Append(inlinedIndependentPreset); } // 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); } return insertionPoint; }