private static void DumpGraph(Stream finalStream, AdjacencyGraph <IBuilder, EquatableEdge <IBuilder> > graph)
{
using (var writer = new DotWriter(finalStream))
{
writer.Rankdir = "RL";
writer.WriteGraph(graph.Edges);
}
}
public void WriteNode_No_Items()
{
var stringBuilder = new StringBuilder();
var writer = new DotWriter(new StringWriter(stringBuilder));
writer.WriteNode("1", "header");
stringBuilder.ToString().Should().BeIgnoringLineEndings("1 [shape=record label=\"{header}\"]\r\n");
}
public void CreateDotFile(Graph graph)
{
FileStream file = new FileStream(graph.Name + ".dot", FileMode.Create, FileAccess.ReadWrite);
StreamWriter streamWriter = new StreamWriter(file, Encoding.GetEncoding(1251));
var dotWriter = new DotWriter(streamWriter);
dotWriter.Write(graph);
streamWriter.Close();
}
private static void DumpCilAst(DevirtualisationContext context, VirtualisedMethod method, string suffix = null)
{
using (var fs = File.CreateText(Path.Combine(context.Options.OutputOptions.CilAstDumpsDirectory, $"function_{method.Function.EntrypointAddress:X4}{suffix}.dot")))
{
WriteHeader(fs, method);
var writer = new DotWriter(fs, new BasicBlockSerializer(method.CallerMethod.CilMethodBody));
writer.Write(method.ControlFlowGraph.ConvertToGraphViz(CilAstBlock.AstBlockProperty));
}
}
public void WriteGraphStart_Should_Write_Name()
{
var stringBuilder = new StringBuilder();
var writer = new DotWriter(new StringWriter(stringBuilder));
writer.WriteGraphStart("test");
stringBuilder.ToString().Should().BeIgnoringLineEndings("digraph \"test\" {\r\n");
}
public void WriteGraphEnd_Test()
{
var stringBuilder = new StringBuilder();
var writer = new DotWriter(new StringWriter(stringBuilder));
writer.WriteGraphEnd();
stringBuilder.ToString().Should().BeIgnoringLineEndings("}\r\n");
}
public void WriteNode_With_Encoding()
{
var stringBuilder = new StringBuilder();
var writer = new DotWriter(new StringWriter(stringBuilder));
writer.WriteNode("1", "header", "\r", "\n", "{", "}", "<", ">", "|", "\"");
stringBuilder.ToString().Should().BeIgnoringLineEndings(@"1 [shape=record label=""{header||\n|\{|\}|\<|\>|\||\""}""]" + "\r\n");
}
private static void DumpILAstTree(DevirtualisationContext context, VirtualisedMethod method)
{
using (var fs = File.CreateText(Path.Combine(context.Options.OutputOptions.ILAstDumpsDirectory,
$"function_{method.Function.EntrypointAddress:X4}_tree.dot")))
{
WriteHeader(fs, method);
var writer = new DotWriter(fs, new BasicBlockSerializer());
writer.Write(method.ILCompilationUnit.ConvertToGraphViz());
}
}
private static void DumpControlFlowGraph(DevirtualisationContext context, VirtualisedMethod method)
{
using (var fs = File.CreateText(Path.Combine(
context.Options.OutputOptions.ILDumpsDirectory,
$"function_{method.Function.EntrypointAddress:X4}.dot")))
{
var writer = new DotWriter(fs, new BasicBlockSerializer());
writer.Write(method.ControlFlowGraph.ConvertToGraphViz(ILBasicBlock.BasicBlockProperty));
}
}
/// <summary>
/// Serializes the data flow graph to the provided output text writer using the dot file format.
/// </summary>
/// <param name="writer">The output stream.</param>
/// <remarks>
/// To customize the look of the resulting dot file graph, use the <see cref="DotWriter"/> class
/// instead of this function.
/// </remarks>
public void ToDotGraph(TextWriter writer)
{
var dotWriter = new DotWriter(writer)
{
NodeIdentifier = new IdentifiedNodeIdentifier(),
NodeAdorner = new DataFlowNodeAdorner <TContents>(),
EdgeAdorner = new DataFlowEdgeAdorner <TContents>()
};
dotWriter.Write(this);
}
private void SaveAsDot(string path)
{
var writer = new DotWriter(path);
if (Model.Presentation.GetModule <IGraphLayoutModule>().Algorithm == LayoutAlgorithm.Flow)
{
writer.Settings = DotPresets.Flow;
}
writer.Write(Model.Presentation.GetModule <ITransformationModule>().Graph, Model.Presentation.Picking, Model.Presentation);
}
public void FSM2Dot1()
{
FSM fa = FSM.FromTerm(CompoundTerm.Parse(FSMTRIANGLE));
GraphParams gp = new GraphParams("Test1", fa);
StringBuilder sb = DotWriter.ToDot(gp);
string s = sb.ToString();
Regex r = new Regex("\\[ label = \"AssignColor\" \\];", RegexOptions.Multiline);
int count = 0;
count = r.Matches(s).Count;
Assert.AreEqual(42, count);
}
private static void Validate(Graph g)
{
var writer = new StringWriter();
var dotWriter = new DotWriter(writer);
dotWriter.Write(g);
var reader = new StringReader(writer.ToString());
var dotReader = new DotReader(reader);
var h = dotReader.Read();
Assert.Equal(g, h, new GraphComparer());
}
private void SyncToDocument(IGraphPresentation p, string path)
{
myFileWatcher.EnableRaisingEvents = false;
using (new Profile("GraphToDotSynchronizer:OnTransformationsChanged"))
{
var graph = new Graph();
foreach (var n in p.Graph.Nodes)
{
graph.TryAdd(n);
}
foreach (var e in p.Graph.Edges)
{
graph.TryAdd(e);
}
var transformationModule = p.GetModule <ITransformationModule>();
foreach (var cluster in transformationModule.Graph.Clusters.OrderBy(c => c.Id))
{
// we do not want to see the pseudo node added for folding but the full expanded list of nodes of this cluster
var folding = transformationModule.Items
.OfType <ClusterFoldingTransformation>()
.SingleOrDefault(f => f.Clusters.Contains(cluster.Id));
// the nodes we get through ITransformationModule might be new instances!
// -> get the right node instances based on the returned ids
// (otherwiese the writer below will remove them from the output)
var nodes = (folding == null ? cluster.Nodes : folding.GetNodes(cluster.Id))
.Select(n => graph.GetNode(n.Id))
.ToList();
graph.TryAdd(new Cluster(cluster.Id, nodes));
}
var writer = new DotWriter(path);
writer.PrettyPrint = true;
if (p.GetModule <IGraphLayoutModule>().Algorithm == LayoutAlgorithm.Flow)
{
writer.Settings = DotPresets.Flow;
}
writer.Write(graph, new NullGraphPicking(), p);
}
myFileWatcher.EnableRaisingEvents = true;
}
private static void Validate(Graph g, bool separate, bool semicolons)
{
var writer = new StringWriter();
var dotWriter = new DotWriter(writer);
dotWriter.SeparateNodesAndEdges = separate;
dotWriter.IncludeSemicolons = semicolons;
dotWriter.Write(g);
var reader = new StringReader(writer.ToString());
var dotReader = new DotReader(reader);
var h = dotReader.Read();
Assert.Equal(g, h, new GraphComparer
{
IncludeUserData = true
});
}
/// <inheritdoc/>
public string ToDot()
{
var writer = new DotWriter <TState>(this.StateComparer);
writer.WriteStart("NFA");
// Accepting states
writer.WriteAcceptingStates(this.AcceptingStates);
// Non-accepting states
writer.WriteStates(this.States.Except(this.AcceptingStates, this.StateComparer));
// Initial states
writer.WriteInitialStates(this.InitialStates);
// Transitions
var tupleComparer = new TupleEqualityComparer <TState, TState>(this.StateComparer, this.StateComparer);
var transitionsByState = this.Transitions.GroupBy(t => (t.Source, t.Destination), tupleComparer);
var remainingEpsilon = this.epsilonTransitions.EpsilonTransitionMap
.ToDictionary(kv => kv.Key, kv => kv.Value.ToHashSet(this.StateComparer), this.StateComparer);
foreach (var group in transitionsByState)
{
var from = group.Key.Item1;
var to = group.Key.Item2;
var on = string.Join(" U ", group.Select(g => g.Symbol));
if (this.EpsilonTransitions.Contains(new(from, to)))
{
remainingEpsilon[from].Remove(to);
on = $"{on}, ε";
}
writer.WriteTransition(from, on, to);
}
// Epsilon-transitions
foreach (var(from, toSet) in remainingEpsilon)
{
foreach (var to in toSet)
{
writer.WriteTransition(from, "ε", to);
}
}
writer.WriteEnd();
return(writer.Code.ToString());
}
/// <summary>
/// Dumps the build context to dot files
/// </summary>
/// <param name="builderGraphStream">Stream where the builder graph will be dumped</param>
/// <param name="rootBuilder">The root builder</param>
public void Dump(Stream builderGraphStream, IBuilder rootBuilder)
{
RunTransformations();
var graph = builders.ToAdjacencyGraph <IBuilder, EquatableEdge <IBuilder> >();
graph.RemoveEdgeIf(edge => edge.IsSelfEdge <IBuilder, EquatableEdge <IBuilder> >());
if (rootBuilder != null)
{
RemoveIrrelevantBranches(graph, rootBuilder);
}
using (var writer = new DotWriter(builderGraphStream))
{
writer.Rankdir = "RL";
writer.WriteGraph(graph.Edges);
}
}
public static int Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += (s, a) => { Console.WriteLine($"Unhandled exception: {((Exception)a.ExceptionObject).Message}"); };
var options = ParseCommandLine(args);
string clonePath = options.ClonePath;
var cloneUrls = File.ReadAllLines(options.CloneUrlsFile);
// load
var gitConfig = new GitConfig
{
CloneBaseFolder = clonePath,
UserName = options.UserName,
Password = options.Password,
RepositoryCloneUrls = cloneUrls,
ShallowClone = true
};
Console.WriteLine($"Starting git clone operation on {cloneUrls.Length} repositories...");
using (var loader = new GitLoader(gitConfig))
{
if (!loader.Success)
{
Console.WriteLine("Loader failed to load; exiting");
return(1);
}
// read
var dependencies = ReadDependencies(new NuGetReader(loader.Location));
// write
var writer = new DotWriter(options.GraphName, options.OutputFileName);
writer.Write(dependencies);
Console.WriteLine("Cleaning up...");
}
Console.WriteLine("Done.");
return(0);
}
private void nodeClick(object sender, TreeNodeMouseClickEventArgs e)
{
string fullPath = e.Node.FullPath;
if (fullPath.ToLower().EndsWith(".sln"))
{
Solution sol = new Solution();
sol.read(fullPath);
string tempfile = "temp.dot";
string retempfile = "retemp.dot";
DotWriter dotWriter = new DotWriter(tempfile);
sol.writeDepsInDotCodeForSolution(dotWriter.dotFile);
dotWriter.Close();
DotWriter.reduceDotfile(tempfile, retempfile);
string pngtemp = "temp.png";
DotWriter.createPngFromDot(retempfile, pngtemp);
this.nwImageViewer1.LoadImage(pngtemp);
this.nwImageViewer1.Invalidate();
}
}
public static void Serialize(string file, IGraphPresentation presentation)
{
var graph = presentation.GetModule <ITransformationModule>().Graph;
if (graph.Nodes.Any(n => presentation.Picking.Pick(n)))
{
Console.WriteLine("Dumping graph ...");
var writer = new DotWriter(file);
writer.PrettyPrint = true;
writer.Write(graph, presentation.Picking, presentation);
}
else
{
Console.WriteLine("Graph is empty");
if (File.Exists(file))
{
File.Delete(file);
}
}
}
public void BuildTest()
{
int inchannels = 4, outchannels = 6, inwidth = 13, inheight = 17, kwidth = 3, kheight = 5, stride = 2, batch = 7;
VariableField x = new Tensor(Shape.Map2D(inchannels, inwidth, inheight, batch));
Layer layer = new Convolution2D(inchannels, outchannels, kwidth, kheight, stride, use_bias: true, pad_mode: PaddingMode.Edge, "conv");
Field y = layer.Forward(x);
(Graph.Node[] nodes, Graph.Edge[] edges) = Graph.Build(y);
Assert.AreEqual(9, nodes.Length);
Assert.AreEqual(8, edges.Length);
foreach (var node in nodes)
{
Console.WriteLine(node.Name);
}
foreach (var edge in edges)
{
Console.WriteLine($"{edge.InNode.Name} -> {edge.OutNode.Name}");
}
DotWriter.Write("test.dot", nodes, edges);
Graph.WriteDotFile("test2.dot", y);
(Flow flow, Parameters parameters) = Flow.Optimize(y);
flow.Execute();
Assert.AreEqual(2, parameters.Count);
Assert.AreEqual(inchannels, layer.InChannels);
Assert.AreEqual(outchannels, layer.OutChannels);
Assert.AreEqual(kwidth, layer.Width);
Assert.AreEqual(kheight, layer.Height);
}
public bool Run(Core.Model.Suite suite, string[] parameters)
{
var effectiveLength = parameters.Length;
var modulesOnly = false;
if (effectiveLength > 0)
{
modulesOnly = effectiveLength >= 1 && parameters[effectiveLength - 1] == "--module";
}
var modules = suite.Modules;
var target = "suite";
if (modulesOnly && effectiveLength > 1 || (!modulesOnly && effectiveLength > 0))
{
var product = parameters[0];
if (suite.HasProduct(product))
{
target = product;
modules = suite.GetProduct(product).Modules;
}
else
{
throw new InvalidCommandParameterException("dependecies", "The given project does not exist");
}
}
try
{
using (var writer = new DotWriter(targetRoot.CreateBinaryFile("deps." + target + ".dot")))
{
var edges = new HashSet <EquatableEdge <string> >();
writer.Rankdir = "LR";
writer.RemoveSelfLoops = true;
foreach (var module in modules)
{
foreach (var project in module.Projects)
{
foreach (var reference in project.References)
{
EquatableEdge <string> edge = null;
if (modulesOnly)
{
edge = GetModuleEdge(reference, project);
}
else
{
edge = GetProjectEdge(reference, project);
}
if (edge != null)
{
edges.Add(edge);
}
}
}
}
writer.WriteGraph(edges);
}
return(true);
}
catch (Exception)
{
return(false);
}
}
private static void DumpGraph(Stream finalStream, AdjacencyGraph<IBuilder, EquatableEdge<IBuilder>> graph)
{
using (var writer = new DotWriter(finalStream))
{
writer.Rankdir = "RL";
writer.WriteGraph(graph.Edges);
}
}
static void Main(string[] args)
{
DotWriter.RunWithCommandLineArguments(args);
}
/// <summary>
/// Dumps the build context to dot files
/// </summary>
/// <param name="builderGraphStream">Stream where the builder graph will be dumped</param>
/// <param name="rootBuilder">The root builder</param>
public void Dump(Stream builderGraphStream, IBuilder rootBuilder)
{
RunTransformations();
var graph = builders.ToAdjacencyGraph<IBuilder, EquatableEdge<IBuilder>>();
graph.RemoveEdgeIf(edge => edge.IsSelfEdge<IBuilder, EquatableEdge<IBuilder>>());
if (rootBuilder != null)
RemoveIrrelevantBranches(graph, rootBuilder);
using (var writer = new DotWriter(builderGraphStream))
{
writer.Rankdir = "RL";
writer.WriteGraph(graph.Edges);
}
}
public CfgWalker(DotWriter writer)
{
this.writer = writer;
}
