public static void EnsureIsAnalyzed(LGSPGraph this_)
{
if (this_.statistics.vstructs == null || this_.changesCounterAtLastAnalyze != this_.ChangesCounter)
{
this_.AnalyzeGraph();
}
}
/// <summary>
/// Copy and extend constructor, creates a named graph from a normal graph.
/// Initializes the name maps with the names provided in a given attribute each graph element must have
/// </summary>
/// <param name="graph">The graph to be used named</param>
/// <param name="nameAttributeName">The name of the attribute to be used for naming</param>
/// <param name="oldToNewMap">A map of the old elements to the new elements after cloning</param>
public LGSPNamedGraph(LGSPGraph graph, String nameAttributeName, out IDictionary <IGraphElement, IGraphElement> oldToNewMap)
: base(graph, graph.Name, out oldToNewMap)
{
NameToElem = new Dictionary <String, IGraphElement>(graph.NumNodes + graph.NumEdges);
ElemToName = new Dictionary <IGraphElement, String>(graph.NumNodes + graph.NumEdges);
DoName(nameAttributeName);
}
public LGSPGraphProcessingEnvironment(LGSPGraph graph, LGSPActions actions)
: base(graph, actions)
{
transactionManager = new LGSPTransactionManager(this);
sequencesManager = new LGSPDeferredSequencesManager();
SetClearVariables(true);
}
public static Edge_slowway CreateEdge(LGSPGraph graph, LGSPNode source, LGSPNode target)
{
Edge_slowway edge = new Edge_slowway(source, target);
graph.AddEdge(edge);
return(edge);
}
void DoIt()
{
graph = new LGSPGraph(new ProgramGraphsOriginalGraphModel());
actions = new ProgramGraphsOriginalActions(graph);
procEnv = new LGSPGraphProcessingEnvironment(graph, actions);
// use new exact 2.5 interface
IClass cls = null;
IMethodBody mb = null;
bool success = actions.createProgramGraphPullUp.Apply(procEnv, ref cls, ref mb);
IMatchesExact <Rule_pullUpMethod.IMatch_pullUpMethod> matchesExact =
actions.pullUpMethod.Match(procEnv, 0, cls, mb);
Console.WriteLine(matchesExact.Count + " matches found.");
Console.WriteLine(matchesExact.FirstExact.node_m5.ToString());
graph.Clear();
// and again with old inexact interface
IMatches matchesInexact;
object[] returns;
Action_createProgramGraphPullUp createProgramGraph = Action_createProgramGraphPullUp.Instance;
matchesInexact = createProgramGraph.Match(procEnv, 0);
returns = createProgramGraph.Modify(procEnv, matchesInexact.First);
IGraphElement[] param = new LGSPNode[2];
param[0] = (Class)returns[0];
param[1] = (MethodBody)returns[1];
matchesInexact = actions.GetAction("pullUpMethod").Match(procEnv, 0, param);
Console.WriteLine(matchesInexact.Count + " matches found.");
Console.WriteLine(matchesInexact.First.getNodeAt((int)Rule_pullUpMethod.pullUpMethod_NodeNums.m5).ToString());
}
public LGSPUniquenessEnsurer(LGSPGraph graph)
{
if (!graph.Model.GraphElementUniquenessIsEnsured)
{
throw new Exception("Internal error, uniqueness ensurer constructed although uniqueness was not requested");
}
if (graph.NumNodes > 0 || graph.NumEdges > 0)
{
throw new Exception("Graph must be empty!");
}
this.graph = graph;
// global counter for fetching a new unique id
nextNewId = 0;
// we use an array organized as heap for storing the "free list" of already allocated but currently not used ids
heap.Add(-1); // we start at index 1, yields simpler arithmetic
// subscribe to events we've to listen to ensure unique ids for the graph elements with a minimum amount of gaps
graph.OnClearingGraph += ClearingGraph;
graph.OnNodeAdded += NodeAdded;
graph.OnEdgeAdded += EdgeAdded;
graph.OnRemovingNode += RemovingNode;
graph.OnRemovingEdge += RemovingEdge;
graph.OnRetypingNode += RetypingNode;
graph.OnRetypingEdge += RetypingEdge;
}
public static Edge_connection CreateEdge(LGSPGraph graph, LGSPNode source, LGSPNode target)
{
Edge_connection edge = new Edge_connection(source, target);
graph.AddEdge(edge);
return(edge);
}
public static Node_Node CreateNode(LGSPGraph graph)
{
Node_Node node = new Node_Node();
graph.AddNode(node);
return(node);
}
public static Node_Process CreateNode(LGSPGraph graph)
{
Node_Process node = new Node_Process();
graph.AddNode(node);
return(node);
}
public LGSPEdge Retype(LGSPGraph graph, LGSPEdge oldEdge)
{
Edge_fluffway newEdge = new Edge_fluffway(oldEdge.source, oldEdge.target);
switch (oldEdge.Type.TypeID)
{
case (int)EdgeTypes.@speedcon:
case (int)EdgeTypes.@bigspeedcon:
case (int)EdgeTypes.@connection:
{
IEdge_connection old = (IEdge_connection)oldEdge;
newEdge.bandwidth = old.bandwidth;
break;
}
case (int)EdgeTypes.@Edge:
{
break;
}
}
graph.ReplaceEdge(oldEdge, newEdge);
return(newEdge);
}
public GraphMatchingState(LGSPGraph graph)
{
++numGraphsComparedAtLeastOnce;
#if LOG_ISOMORPHY_CHECKING
if (writer == null)
{
writer = new StreamWriter("isocheck_log.txt");
}
// print out the names of the type ids referenced in the interpretation plan when the first graph is initialized
if (numGraphsComparedAtLeastOnce == 1)
{
foreach (NodeType nodeType in graph.Model.NodeModel.Types)
{
writer.WriteLine(nodeType.TypeID + " is node type " + nodeType.Name);
}
foreach (EdgeType edgeType in graph.Model.EdgeModel.Types)
{
writer.WriteLine(edgeType.TypeID + " is edge type " + edgeType.Name);
}
writer.Flush();
}
#endif
}
private static void BuildInterpretationPlan(LGSPGraph graph)
{
graph.matchingState.patternGraph = BuildPatternGraph(graph);
PlanGraph planGraph = PlanGraphGenerator.GeneratePlanGraph(graph.Model, graph.statistics, graph.matchingState.patternGraph,
false, false, false, new Dictionary <PatternElement, SetValueType>());
PlanGraphGenerator.MarkMinimumSpanningArborescence(planGraph, graph.matchingState.patternGraph.name, false);
SearchPlanGraph searchPlanGraph = SearchPlanGraphGeneratorAndScheduler.GenerateSearchPlanGraph(planGraph);
ScheduledSearchPlan scheduledSearchPlan = SearchPlanGraphGeneratorAndScheduler.ScheduleSearchPlan(
searchPlanGraph, graph.matchingState.patternGraph, false, false);
InterpretationPlanBuilder builder = new InterpretationPlanBuilder(scheduledSearchPlan, searchPlanGraph, graph.Model);
graph.matchingState.interpretationPlan = builder.BuildInterpretationPlan("ComparisonMatcher_" + graph.GraphId);
++GraphMatchingState.numInterpretationPlans;
graph.matchingState.changesCounterAtInterpretationPlanBuilding = graph.changesCounterAtLastAnalyze;
Debug.Assert(graph.changesCounterAtLastAnalyze == graph.ChangesCounter);
#if LOG_ISOMORPHY_CHECKING
SourceBuilder sb = new SourceBuilder();
graph.matchingState.interpretationPlan.Dump(sb);
writer.WriteLine();
writer.WriteLine(sb.ToString());
writer.WriteLine();
writer.Flush();
#endif
}
/// <summary>
/// Copy and extend constructor, creates a named graph from a normal graph.
/// Initializes the name maps with anonymous names in the form "$" + GetNextName()
/// </summary>
/// <param name="graph">The graph to be used named</param>
public LGSPNamedGraph(LGSPGraph graph)
: base(graph, graph.Name, out tmpOldToNewMap)
{
NameToElem = new Dictionary <String, IGraphElement>(graph.NumNodes + graph.NumEdges);
ElemToName = new Dictionary <IGraphElement, String>(graph.NumNodes + graph.NumEdges);
tmpOldToNewMap = null;
DoName();
}
public LGSPActionExecutionEnvironment(LGSPGraph graph, LGSPActions actions)
{
// TODO: evt. IGraph + BaseActions und dann hier cast auf LGSP, mal gucken was an Schnittstelle besser paßt
this.usedGraphs = new Stack <LGSPGraph>();
this.usedGraphs.Push(graph);
this.namedGraphOnTop = graph as LGSPNamedGraph;
this.curActions = actions;
InitActionsProfile(actions);
}
public LGSPUniquenessIndex(LGSPGraph graph)
: base(graph)
{
if (!graph.Model.GraphElementsAreAccessibleByUniqueId)
{
throw new Exception("Internal error, uniqueness index constructed although access by unique id was not requested");
}
index = new List <IGraphElement>();
}
/// <summary>
/// Constructs a new LGSPActions instance.
/// This constructor is deprecated.
/// </summary>
/// <param name="lgspgraph">The associated graph.</param>
/// <param name="modelAsmName">The name of the model assembly.</param>
/// <param name="actionsAsmName">The name of the actions assembly.</param>
public LGSPActions(LGSPGraph lgspgraph, String modelAsmName, String actionsAsmName)
{
graph = lgspgraph;
modelAssemblyName = modelAsmName;
actionsAssemblyName = actionsAsmName;
matcherGenerator = new LGSPMatcherGenerator(graph.Model);
#if ASSERT_ALL_UNMAPPED_AFTER_MATCH
OnMatched += new AfterMatchHandler(AssertAllUnmappedAfterMatch);
#endif
}
public virtual void FillAsClone(LGSPGraph originalGraph, IDictionary <IGraphElement, IGraphElement> oldToNewMap)
{
LGSPUniquenessEnsurer original = originalGraph.uniquenessEnsurer;
nextNewId = original.nextNewId;
heap.Clear(); // remove the -1
heap.Capacity = original.heap.Capacity;
heap.AddRange(original.heap);
}
public LGSPActionExecutionEnvironment(LGSPGraph graph, LGSPActions actions)
{
usedGraphs = new Stack <LGSPGraph>();
usedGraphs.Push(graph);
namedGraphOnTop = graph as LGSPNamedGraph;
curActions = actions;
InitActionsProfile(actions);
customCommandsToDescriptions = new Dictionary <string, string>();
FillCustomCommandDescriptions();
}
static void PrintResults(int duration, LGSPGraph graph)
{
Console.WriteLine("Mutex benchmark: " + duration + " ms");
Console.WriteLine("Number of nodes: " + graph.NumNodes);
Console.WriteLine("Number of edges: " + graph.NumEdges);
Console.WriteLine("Number of Process nodes: " + graph.GetNumExactNodes(Process.TypeInstance));
Console.WriteLine("Number of Resource nodes: " + graph.GetNumExactNodes(Resource.TypeInstance));
Console.WriteLine("Number of next edges: " + graph.GetNumExactEdges(next.TypeInstance));
Console.WriteLine("Number of request edges: " + graph.GetNumExactEdges(request.TypeInstance));
Console.WriteLine("Number of token edges: " + graph.GetNumExactEdges(token.TypeInstance));
}
/// <summary>
/// Creates a new LGSPGraph and LGSPActions instance from the specified specification file.
/// If the according dlls do not exist or are out of date, the needed processing steps are performed automatically.
/// A name for the graph is automatically generated.
/// </summary>
/// <param name="grgFilename">Filename of the rule specification file (.grg).</param>
/// <param name="statisticsPath">Optional path to a file containing the graph statistics to be used for building the matchers.</param>
/// <param name="newGraph">Returns the new graph.</param>
/// <param name="newActions">Returns the new BaseActions object.</param>
/// <exception cref="System.IO.FileNotFoundException">Thrown, when a needed specification file does not exist.</exception>
/// <exception cref="System.Exception">Thrown, when something goes wrong.</exception>
public void CreateFromSpec(String grgFilename, String statisticsPath,
out LGSPGraph newGraph, out LGSPActions newActions)
{
LGSPGraph graph;
LGSPActions actions;
CreateFromSpec(grgFilename, GetNextGraphName(), statisticsPath, ProcessSpecFlags.UseNoExistingFiles, new List <String>(), false, 0,
out graph, out actions);
newGraph = graph;
newActions = actions;
}
/// <summary>
/// Constructs a new LGSPActions instance.
/// </summary>
/// <param name="lgspgraph">The associated graph.</param>
public LGSPActions(LGSPGraph lgspgraph)
{
graph = lgspgraph;
matcherGenerator = new LGSPMatcherGenerator(graph.Model);
modelAssemblyName = Assembly.GetAssembly(graph.Model.GetType()).Location;
actionsAssemblyName = Assembly.GetAssembly(this.GetType()).Location;
#if ASSERT_ALL_UNMAPPED_AFTER_MATCH
OnMatched += new AfterMatchHandler(AssertAllUnmappedAfterMatch);
#endif
}
public override IGraphElement[] ModifyNoReuse(LGSPGraph graph, LGSPMatch match)
{
LGSPNode node_p2 = match.nodes[(int)NodeNums.@p2 - 1];
LGSPNode node_p1 = match.nodes[(int)NodeNums.@p1 - 1];
LGSPEdge edge__edge0 = match.edges[(int)EdgeNums.@_edge0 - 1];
LGSPNode node__node0 = graph.AddNode(NodeType_Process.typeVar);
LGSPEdge edge__edge1 = graph.AddEdge(EdgeType_connection.typeVar, node_p1, node__node0);
LGSPEdge edge__edge2 = graph.AddEdge(EdgeType_connection.typeVar, node__node0, node_p2);
graph.Remove(edge__edge0);
return(EmptyReturnElements);
}
public LGSPNode Retype(LGSPGraph graph, LGSPNode oldNode)
{
Node_Process newNode = new Node_Process();
graph.AddNodeWithoutEvents(newNode, (int)NodeTypes.@Process);
switch (oldNode.Type.TypeID)
{
case (int)NodeTypes.@Process:
{
Node_Process old = (Node_Process)oldNode;
newNode.val = old.val;
newNode.name = old.name;
break;
}
case (int)NodeTypes.@Node:
{
break;
}
}
// Reassign all outgoing edges
LGSPEdge outHead = oldNode.outhead;
if (outHead != null)
{
LGSPEdge outCur = outHead;
do
{
outCur.source = newNode;
outCur = outCur.outNext;
}while(outCur != outHead);
}
newNode.outhead = outHead;
// Reassign all incoming edges
LGSPEdge inHead = oldNode.outhead;
if (inHead != null)
{
LGSPEdge inCur = inHead;
do
{
inCur.target = newNode;
inCur = inCur.inNext;
}while(inCur != inHead);
}
newNode.inhead = inHead;
return(newNode);
}
static void PrintResults(int duration, LGSPGraph graph)
{
Console.WriteLine("AntWorld benchmark: " + duration + " ms");
Console.WriteLine("Number of nodes: " + graph.NumNodes);
Console.WriteLine("Number of edges: " + graph.NumEdges);
Console.WriteLine("Number of Process nodes: " + graph.GetNumExactNodes(Ant.TypeInstance));
Console.WriteLine("Number of Resource nodes: " + graph.GetNumExactNodes(GridNode.TypeInstance));
Console.WriteLine("Number of Process nodes: " + graph.GetNumExactNodes(GridCornerNode.TypeInstance));
Console.WriteLine("Number of Resource nodes: " + graph.GetNumExactNodes(AntHill.TypeInstance));
Console.WriteLine("Number of next edges: " + graph.GetNumExactEdges(NextAnt.TypeInstance));
Console.WriteLine("Number of request edges: " + graph.GetNumExactEdges(GridEdge.TypeInstance));
Console.WriteLine("Number of token edges: " + graph.GetNumExactEdges(PathToHill.TypeInstance));
Console.WriteLine("Number of token edges: " + graph.GetNumExactEdges(AntPosition.TypeInstance));
}
/// <summary>
/// Constructs a new LGSPActions instance.
/// This constructor is deprecated.
/// </summary>
/// <param name="lgspgraph">The associated graph.</param>
/// <param name="modelAsmName">The name of the model assembly.</param>
/// <param name="actionsAsmName">The name of the actions assembly.</param>
protected LGSPActions(LGSPGraph lgspgraph, String modelAsmName, String actionsAsmName)
{
graph = lgspgraph;
modelAssemblyName = modelAsmName;
actionsAssemblyName = actionsAsmName;
matcherGenerator = new LGSPMatcherGenerator(graph.Model);
customCommandsToDescriptions = new Dictionary <string, string>();
FillCustomCommandDescriptions();
#if ASSERT_ALL_UNMAPPED_AFTER_MATCH
OnMatched += new AfterMatchHandler(AssertAllUnmappedAfterMatch);
#endif
}
public override void FillAsClone(LGSPGraph originalGraph, IDictionary <IGraphElement, IGraphElement> oldToNewMap)
{
base.FillAsClone(originalGraph, oldToNewMap);
LGSPUniquenessIndex original = (LGSPUniquenessIndex)originalGraph.uniquenessEnsurer;
if (original.index != null)
{
index = new List <IGraphElement>(original.index.Capacity);
for (int i = 0; i < original.index.Count; ++i)
{
index.Add(oldToNewMap[original.index[i]]);
}
}
}
/// <summary>
/// Constructs a new LGSPActions instance.
/// </summary>
/// <param name="lgspgraph">The associated graph.</param>
protected LGSPActions(LGSPGraph lgspgraph)
{
graph = lgspgraph;
matcherGenerator = new LGSPMatcherGenerator(graph.Model);
modelAssemblyName = Assembly.GetAssembly(graph.Model.GetType()).Location;
actionsAssemblyName = Assembly.GetAssembly(this.GetType()).Location;
customCommandsToDescriptions = new Dictionary <string, string>();
FillCustomCommandDescriptions();
#if ASSERT_ALL_UNMAPPED_AFTER_MATCH
OnMatched += new AfterMatchHandler(AssertAllUnmappedAfterMatch);
#endif
}
public void DoUndo(IGraphProcessingEnvironment procEnv)
{
String name;
if (procEnv.Graph is LGSPNamedGraph && ((LGSPNamedGraph)procEnv.Graph).ElemToName.TryGetValue(_newElem, out name))
{
LGSPNamedGraph lgspGraph = (LGSPNamedGraph)procEnv.Graph;
if (_newElem is INode)
{
LGSPNode newNode = (LGSPNode)_newElem;
LGSPNode oldNode = (LGSPNode)_oldElem;
lgspGraph.ElemToName[oldNode] = name;
lgspGraph.RetypingNode(newNode, oldNode); // this will switch the variables
lgspGraph.ReplaceNode(newNode, oldNode);
lgspGraph.ElemToName.Remove(newNode);
lgspGraph.NameToElem[name] = oldNode;
}
else
{
LGSPEdge newEdge = (LGSPEdge)_newElem;
LGSPEdge oldEdge = (LGSPEdge)_oldElem;
lgspGraph.ElemToName[oldEdge] = name;
lgspGraph.RetypingEdge(newEdge, oldEdge); // this will switch the variables
lgspGraph.ReplaceEdge(newEdge, oldEdge);
lgspGraph.ElemToName.Remove(newEdge);
lgspGraph.NameToElem[name] = oldEdge;
}
}
else
{
LGSPGraph lgspGraph = (LGSPGraph)procEnv.Graph;
if (_newElem is INode)
{
LGSPNode newNode = (LGSPNode)_newElem;
LGSPNode oldNode = (LGSPNode)_oldElem;
lgspGraph.RetypingNode(newNode, oldNode); // this will switch the variables
lgspGraph.ReplaceNode(newNode, oldNode);
}
else
{
LGSPEdge newEdge = (LGSPEdge)_newElem;
LGSPEdge oldEdge = (LGSPEdge)_oldElem;
lgspGraph.RetypingEdge(newEdge, oldEdge); // this will switch the variables
lgspGraph.ReplaceEdge(newEdge, oldEdge);
}
}
}
void DoIter()
{
graph = new LGSPGraph(new StdGraphModel());
actions = new spanningTreeActions(graph);
procEnv = new LGSPGraphProcessingEnvironment(graph, actions);
IAction_initUndirected init = actions.initUndirected;
IMatchesExact <Rule_initUndirected.IMatch_initUndirected> matchesInitUndirected = init.Match(procEnv, 0);
INode root;
init.Modify(procEnv, matchesInitUndirected.FirstExact, out root);
IMatchesExact <Rule_spanningTree.IMatch_spanningTree> matchesSpanningTree = actions.spanningTree.Match(procEnv, 0, root);
actions.spanningTree.Modify(procEnv, matchesSpanningTree.FirstExact);
Console.WriteLine(matchesSpanningTree.Count + " matches found.");
}
public LGSPMatches myMatch(LGSPGraph graph, int maxMatches, IGraphElement[] parameters)
{
matches.matches.Clear();
// Lookup(edge__edge0:connection)
foreach (EdgeType edge_type_edge__edge0 in EdgeType_connection.typeVar.SubOrSameTypes)
{
for (LGSPEdge edge_head_edge__edge0 = graph.edgesByTypeHeads[edge_type_edge__edge0.TypeID], edge_cur_edge__edge0 = edge_head_edge__edge0.typeNext; edge_cur_edge__edge0 != edge_head_edge__edge0; edge_cur_edge__edge0 = edge_cur_edge__edge0.typeNext)
{
// ImplicitTarget(edge__edge0 -> node_p2:Process)
LGSPNode node_cur_node_p2 = edge_cur_edge__edge0.target;
if (!NodeType_Process.isMyType[node_cur_node_p2.type.TypeID])
{
goto contunmap_edge_cur_edge__edge0_2;
}
node_cur_node_p2.mappedTo = 1;
// ImplicitSource(edge__edge0 -> node_p1:Process)
LGSPNode node_cur_node_p1 = edge_cur_edge__edge0.source;
if (!NodeType_Process.isMyType[node_cur_node_p1.type.TypeID])
{
goto contunmap_node_cur_node_p2_4;
}
if (node_cur_node_p1.mappedTo != 0)
{
goto cont_node_cur_node_p1_7;
}
LGSPMatch match = matchesList.GetNewMatch();
match.nodes[0] = node_cur_node_p2;
match.nodes[1] = node_cur_node_p1;
match.edges[0] = edge_cur_edge__edge0;
matchesList.CommitMatch();
if (maxMatches > 0 && matchesList.Count >= maxMatches)
{
node_cur_node_p2.mappedTo = 0;
graph.MoveHeadAfter(edge_cur_edge__edge0);
return(matches);
}
cont_node_cur_node_p1_7 :;
contunmap_node_cur_node_p2_4 :;
node_cur_node_p2.mappedTo = 0;
contunmap_edge_cur_edge__edge0_2 :;
// Tail of Lookup(edge_cur_edge__edge0)
}
}
return(matches);
}
