public static void Add(GraphWriter g, ModelBuilder modelBuilder, bool useContainers) { GraphBuilder graphBuilder = new GraphBuilder(); graphBuilder.UseContainers = useContainers; graphBuilder.Add(g, modelBuilder); }
protected Edge AddEdge(GraphWriter g, IModelExpression from, IModelExpression to, string name) { Node sourceNode = GetNode(g, from); Node targetNode = GetNode(g, to); childNodes.Add(targetNode); return(AddEdge(g, sourceNode, targetNode, name)); }
protected void AddFactorEdges(GraphWriter g, MethodInvoke mi) { var parameters = mi.method.GetParameters(); for (int i = 0; i < mi.args.Count; i++) { var parameter = parameters[i]; if (parameter.IsOut) { AddEdge(g, mi, mi.args[i], parameter.Name); } else { AddEdge(g, mi.args[i], mi, parameter.Name); } } if (mi.returnValue != null) { AddEdge(g, mi, mi.returnValue, ""); } if (!UseContainers) { // add edges from condition variables to target (if there are no such edges already) IModelExpression target = (mi.returnValue != null) ? mi.returnValue : mi; Set <IStatementBlock> excluded = new Set <IStatementBlock>(); if (target is Variable) { // if target is in the ConditionBlock, then don't connect with the condition variable Variable targetVar = (Variable)target; excluded.AddRange(targetVar.Containers); } foreach (IStatementBlock block in mi.Containers) { if (excluded.Contains(block)) { continue; } if (block is ConditionBlock) { ConditionBlock cb = (ConditionBlock)block; Variable c = cb.ConditionVariableUntyped; List <Variable> condVars; if (!conditionVariables.TryGetValue(target, out condVars)) { condVars = new List <Variable>(); conditionVariables[target] = condVars; } if (!condVars.Contains(c)) { AddEdge(g, c, target, "condition"); condVars.Add(c); } } } } }
protected Edge AddEdge(GraphWriter g, Node sourceNode, Node targetNode, string name) { string source = sourceNode.ID; string target = targetNode.ID; Edge edge = g.AddEdge(source, target); edge.Label = name; edge.FontSize = 8; edge.FontColor = Color.LightGray; return(edge); }
/// <summary> /// Write the graph to a file in DOT format /// </summary> /// <param name="path"></param> public void WriteDot(string path) { // References: // https://en.wikipedia.org/wiki/DOT_(graph_description_language) var builder = new GraphBuilder(); builder.UseContainers = true; GraphWriter g = builder.ToGraph(modelBuilder); g.Write(path); }
private void Add(GraphWriter g, ModelBuilder mb) { Count = 0; if (mb == null) { return; } foreach (IModelExpression me in mb.ModelExpressions) { if (me is MethodInvoke) { AddFactorEdges(g, (MethodInvoke)me); } } // connect nodes that represent the same variable with undirected edges Dictionary <Variable, List <Node> > nodesOfVariable = new Dictionary <Variable, List <Node> >(); foreach (KeyValuePair <IModelExpression, Node> entry in nodeOfExpr) { if (!(entry.Key is Variable)) { continue; } Variable v = (Variable)entry.Key; v = GetBaseVariable(v); List <Node> nodes; if (!nodesOfVariable.TryGetValue(v, out nodes)) { nodes = new List <Node>(); nodesOfVariable[v] = nodes; } nodes.Add(entry.Value); } foreach (List <Node> nodes in nodesOfVariable.Values) { for (int i = 0; i < nodes.Count; i++) { for (int j = 0; j < nodes.Count; j++) { if (i != j && childNodes.Contains(nodes[i])) { // Graph layout tools use the edge direction as a layout hint, so only use child nodes as sources Edge edge = g.AddEdge(nodes[i].ID, nodes[j].ID); edge.ArrowheadAtTarget = ArrowheadStyle.None; } } } } }
//CodeTransformer ct = new CodeTransformer(); protected Node AddNode(GraphWriter g, IStatement ist, Stage stage) { if (ist is ICommentStatement) { return(null); } Node nd = GetNodeForStatement(ist, stage); if (nd != null) { nd.Label = Count + "," + nd.Label; Count++; return(nd); } DependencyInformation di = context.InputAttributes.Get <DependencyInformation>(ist); if ((di != null) && (di.IsOutput)) { return(null); } string s = Count + ". " + StatementLabel(ist); nd = g.AddNode("node" + Count); nd.UserData = Count++; SetNodeForStatement(ist, stage, nd); //if (di.IsOutput) nd.Fillcolor = Color.LightBlue; nd.Label = s; if (stage == Stage.Initialisation) { nd.FillColor = Color.LightGray; } if (ist is IExpressionStatement) { IExpressionStatement ies = (IExpressionStatement)ist; IAssignExpression iae = ies.Expression as IAssignExpression; if ((iae != null) && (iae.Target is IVariableDeclarationExpression)) { nd.BorderWidth = 2; } } nd.Shape = ShapeStyle.Box; nd.FontSize = 9; return(nd); }
protected void AddEdges(GraphWriter g, IStatement ist, Stage stage) { Node nd = GetNodeForStatement(ist, stage); if (nd == null) { return; } DependencyInformation di = context.InputAttributes.Get <DependencyInformation>(ist); if (di == null) { return; } AddDependencyEdges(g, nd, di, Stage.Initialisation, stage); if (stage != Stage.Initialisation) { AddDependencyEdges(g, nd, di, Stage.Update, stage); } }
protected void AddDependencyEdges(GraphWriter g, Node nd, DependencyInformation di, Stage stage, Stage parentStage) { foreach (IStatement source in di.GetDependenciesOfType(DependencyType.Dependency | DependencyType.Declaration)) { Node nd2 = GetNodeForStatement(source, stage); if (nd2 == null) { continue; } bool backwards = ((int)nd.UserData) < ((int)nd2.UserData); //Console.WriteLine("stage=" + stage + " " + nd.UserData + " " + nd2.UserData); Edge e; if (backwards) { e = g.AddEdge(nd.ID, nd2.ID); e.Color = Color.Red; e.Reverse = true; } else { e = g.AddEdge(nd2.ID, nd.ID); if (parentStage != stage) { e.Color = Color.LightGray; } } if (di.HasDependency(DependencyType.Trigger, source)) { e.Width = 2; } if (di.HasDependency(DependencyType.Fresh, source)) { e.Style = EdgeStyle.Dashed; } if (di.HasDependency(DependencyType.Cancels, source)) { e.Color = Color.LightGray; } } //e.Label = StatementLabel(ist); e.Label.FontSize = 8; }
protected Node GetNode(GraphWriter g, ConditionContext context) { Node node; if (!nodeOfContext.TryGetValue(context, out node)) { node = g.AddNode("node" + (Count++)); nodeOfContext[context] = node; node.Label = context.GetLabel(); node.UserData = this.GroupInstance; ConditionContext parent = context.GetParentContext(); if (parent != null) { var parentNode = GetNode(g, parent); AddGroupEdge(g, parentNode, node); } var variable = context.GetConditionVariable(); Node conditionNode = GetNode(g, variable); g.AddEdge(conditionNode.ID, node.ID); } return(node); }
protected void OnModelChange() { var builder = new GraphBuilder(); graph = builder.ToGraph(modelBuilder); }
protected void AddGroupEdge(GraphWriter g, Node parent, Node child) { Edge edge = g.AddEdge(parent.ID, child.ID); edge.UserData = this.GroupInstance; }
protected Node GetNode(GraphWriter g, IModelExpression expr) { if (nodeOfExpr.ContainsKey(expr)) { return(nodeOfExpr[expr]); } Node nd = g.AddNode("node" + (Count++)); nodeOfExpr[expr] = nd; nd.Label = expr.ToString(); nd.FontSize = 9; if (expr is Variable) { Variable ve = (Variable)expr; if (ve.IsObserved) { nd.Shape = ShapeStyle.None; if (ve.IsBase) { // if the observed value is a ValueType, display it directly rather than the variable name object value = ((HasObservedValue)ve).ObservedValue; if (ReferenceEquals(value, null)) { nd.Label = "null"; } else if (value.GetType().IsValueType) { nd.Label = value.ToString(); } } } if (!ve.IsReadOnly) { nd.FontSize = 10; nd.FontColor = Color.Blue; } if (UseContainers && ve.Containers.Count > 0) { var context = ConditionContext.GetContext(ve.Containers); if (context != null) { var contextNode = GetNode(g, context); AddGroupEdge(g, contextNode, nd); } } } else if (expr is MethodInvoke) { MethodInvoke mi = (MethodInvoke)expr; nd.FillColor = Color.Black; nd.FontColor = Color.White; nd.Shape = ShapeStyle.Box; nd.FontSize = 8; string methodName = mi.method.Name; if (mi.op != null) { methodName = mi.op.ToString(); } nd.Label = methodName; if (UseContainers && mi.Containers.Count > 0) { var context = ConditionContext.GetContext(mi.Containers); if (context != null) { var contextNode = GetNode(g, context); AddGroupEdge(g, contextNode, nd); } } } return(nd); }
protected void OnModelChange() { graph = new DotGraphWriter("Model"); GraphBuilder.Add(graph, modelBuilder, false); }
protected void OnTasksChanged() { graph = ToGraph(pretasks, looptasks); }