/// <inheritdoc />
protected override void SetupCompileCppFilesArgs(TaskGraph graph, BuildOptions options, List <string> args, string outputPath)
{
base.SetupCompileCppFilesArgs(graph, options, args, outputPath);
args.Add(string.Format("-target {0}", ArchitectureName));
args.Add(string.Format("--sysroot=\"{0}\"", ToolsetRoot.Replace('\\', '/')));
}
private Dictionary <int, TickState> createInitialTickState(TaskGraph tasksGraph, ComputingSystem computingSystem)
{
var readyJobs = new List <Job>();
var readyProcessors = new List <Processor>();
foreach (var job in tasksGraph)
{
if (!job.Parents.Any())
{
readyJobs.Add(job);
}
}
foreach (var proc in computingSystem)
{
readyProcessors.Add(proc);
}
var ticksDesc = new Dictionary <int, TickState>();
ticksDesc[1] = new TickState
{
ReadyJobs = readyJobs,
ReadyProcessors = readyProcessors
};
return(ticksDesc);
}
public JobDefinition()
{
Name = string.Empty;
Tasks = new List<TaskRequest>();
Files = new List<FileRequest>();
Graph = new TaskGraph();
}
protected Scheduler(TaskGraph graph, int?maxThreadCount)
{
this.graph = graph;
this.workerList = new List <Worker>();
// If no threadCount is given, set to one per core.
if (maxThreadCount == null)
{
int coreCount = 0;
foreach (var item in new System.Management.ManagementObjectSearcher("Select * from Win32_Processor").Get())
{
coreCount += int.Parse(item["NumberOfCores"].ToString());
}
Console.WriteLine("Number Of Cores: {0}", coreCount);
WorkerCount = coreCount;
}
else
{
WorkerCount = (int)maxThreadCount;
}
for (int i = 0; i < WorkerCount; i++)
{
workerList.Add(new Worker(i));
}
}
/// <inheritdoc />
protected override void SetupLinkFilesArgs(TaskGraph graph, BuildOptions options, List <string> args, string outputFilePath)
{
base.SetupLinkFilesArgs(graph, options, args, outputFilePath);
// Speed up build
//args.Add("-Wl,--as-needed");
args.Add("-Wl,--hash-style=gnu");
//args.Add("-Wl,--build-id");
if (options.LinkEnv.Output == LinkerOutput.SharedLibrary)
{
args.Add("-shared");
args.Add(string.Format("-soname=\"{0}\"", Path.GetFileNameWithoutExtension(outputFilePath)));
}
args.Add(string.Format("-target {0}", ArchitectureName));
args.Add(string.Format("--sysroot=\"{0}\"", ToolsetRoot.Replace('\\', '/')));
// Link core libraries
args.Add("-pthread");
args.Add("-ldl");
args.Add("-lrt");
// Link X11
args.Add("-L/usr/X11R6/lib");
args.Add("-lX11");
args.Add("-lXcursor");
args.Add("-lXinerama");
}
/// <inheritdoc />
protected override Task CreateBinary(TaskGraph graph, BuildOptions options, string outputFilePath)
{
var task = base.CreateBinary(graph, options, outputFilePath);
task.CommandPath = ClangPath;
return(task);
}
/// <inheritdoc />
protected override void SetupArchiveFilesArgs(TaskGraph graph, BuildOptions options, List <string> args, string outputFilePath)
{
// Remove -o from the output file specifier
args[1] = string.Format("\"{0}\"", outputFilePath);
base.SetupArchiveFilesArgs(graph, options, args, outputFilePath);
}
/// <inheritdoc />
public override void PostBuild(TaskGraph graph, BuildOptions buildOptions)
{
base.PostBuild(graph, buildOptions);
// If building engine executable for platform doesn't support referencing it when linking game shared libraries
if (UseSeparateMainExecutable(buildOptions))
{
// Build additional executable with Main module only that uses shared library
using (new ProfileEventScope("BuildExecutable"))
{
BuildMainExecutable(graph, buildOptions);
}
// Restore state from PreBuild
Modules.Add("Main");
}
// Mono on Linux is using dynamic linking and needs additional link files
if (buildOptions.Platform.Target == TargetPlatform.Linux && Platform.BuildTargetPlatform == TargetPlatform.Linux && !IsPreBuilt)
{
var task = graph.Add <Task>();
task.PrerequisiteFiles.Add(Path.Combine(buildOptions.OutputFolder, "libmonosgen-2.0.so"));
task.ProducedFiles.Add(Path.Combine(buildOptions.OutputFolder, "libmonosgen-2.0.so.1"));
task.WorkingDirectory = buildOptions.OutputFolder;
task.CommandPath = "ln";
task.CommandArguments = "-s -f libmonosgen-2.0.so libmonosgen-2.0.so.1";
task = graph.Add <Task>();
task.PrerequisiteFiles.Add(Path.Combine(buildOptions.OutputFolder, "libmonosgen-2.0.so"));
task.ProducedFiles.Add(Path.Combine(buildOptions.OutputFolder, "libmonosgen-2.0.so.1.0.0"));
task.WorkingDirectory = buildOptions.OutputFolder;
task.CommandPath = "ln";
task.CommandArguments = "-s -f libmonosgen-2.0.so libmonosgen-2.0.so.1.0.0";
}
}
/// <inheritdoc />
protected override Task CreateArchive(TaskGraph graph, BuildOptions options, string outputFilePath)
{
var task = base.CreateArchive(graph, options, outputFilePath);
task.CommandPath = LlvmArPath;
return(task);
}
static void WorkThread(TaskGraph taskGraph)
{
while (true)
{
taskGraph.mEventDispatch.Wait();
{
if (taskGraph.mEventExit.Wait(0))
{
break;
}
taskGraph.mEventReady.Signal();
taskGraph.mEventReady.Wait();
if (taskGraph.mTaskListHeads.Count > 0 && taskGraph.mTaskListDependence.Count > 0)
{
TaskEvent taskEvent = taskGraph.mEventRun;
do
{
taskEvent.Wait();
while (true)
{
bool bFinish = false;
TaskBase task = null;
taskGraph.mMutex.WaitOne();
{
if (taskGraph.mTaskListHeads.ContainsKey(taskEvent) && taskGraph.mTaskListHeads[taskEvent] != null)
{
task = taskGraph.mTaskListHeads[taskEvent];
taskGraph.mTaskListHeads[taskEvent] = taskGraph.mTaskListHeads[taskEvent].Next;
}
else
{
bFinish = true;
}
}
taskGraph.mMutex.ReleaseMutex();
if (task != null)
{
task.TaskFunc();
task.SetEventSignal();
}
if (bFinish)
{
break;
}
}
taskEvent = taskGraph.mTaskListDependence.Count > 0 ? taskGraph.mTaskListDependence[taskEvent] : null;
} while (taskEvent != null);
}
}
taskGraph.mEventDispatch.Reset();
taskGraph.mEventFinish.Signal();
}
}
/// <summary>
/// Cleans the build system cache and intermediate results.
/// </summary>
public static void Clean()
{
using (new ProfileEventScope("Clean"))
{
var graph = new TaskGraph(Globals.Root);
graph.CleanCache();
}
}
public Dynamic(TaskGraph graph, int?maxThreadCount = null) : base(graph, maxThreadCount)
{
this.graph.ComputeSLevel();
var initialList = this.graph.SortBySLevel().Where(x => x.IsReadyToExecute).ToList();
readyList = new ReadyTaskList(initialList);
workers = new ReadyWorkerList(WorkerCount);
}
public override void Execute()
{
if (Application.DisplayManual)
{
ForgeTool.DisplayManual();
}
else
{
TaskGraph.SetEndPoints(Application.Profile.GetEndPoints());
AppDomain.CurrentDomain.GetAssemblies().ParallelFor((assembly) =>
{
foreach (Type task in assembly.GetTypes <ITaskPrototype>())
{
if (!task.IsAbstract)
{
try
{
TaskPrototypes.Add(task.CreateInstance <ITaskPrototype>());
}
catch (Exception er)
{
if (Application.LogSeverity == SeverityFlags.Full)
{
Application.Error(SeverityFlags.None, "{0}{1}{2}", er.Message, Environment.NewLine, er.StackTrace);
}
else
{
Application.Error(SeverityFlags.None, er.Message);
}
}
}
}
});
foreach (FileDescriptor file in Application.GetBuildFiles())
{
outputPins.Add(new FlaggedPin(this, file, SystemTags.SealedSetup));
}
UInt32 flag; if (outputPins.Count > 0)
{
flag = SystemTags.SealedSetup;
}
else
{
flag = SystemTags.ForgeSetup;
}
foreach (PathDescriptor path in Application.GetBuildPaths())
{
outputPins.Add(new FlaggedPin(this, path, flag));
}
if (outputPins.Count == 0)
{
Application.Error(SeverityFlags.None, "Build paths not valid");
}
}
}
/// <inheritdoc />
protected override void SetupCompileCppFilesArgs(TaskGraph graph, BuildOptions options, List <string> args, string outputPath)
{
base.SetupCompileCppFilesArgs(graph, options, args, outputPath);
var toolchain = ToolsetRoot.Replace('\\', '/');
args.Add(string.Format("--target={0}", ArchitectureName));
args.Add(string.Format("--gcc-toolchain=\"{0}\"", toolchain));
args.Add(string.Format("--sysroot=\"{0}/sysroot\"", toolchain));
args.Add("-fpic");
args.Add("-funwind-tables");
args.Add("-no-canonical-prefixes");
if (options.Configuration != TargetConfiguration.Release)
{
args.Add("-fstack-protector-strong");
args.Add("-D_FORTIFY_SOURCE=2");
}
else
{
args.Add("-D_FORTIFY_SOURCE=1");
}
if (options.CompileEnv.DebugInformation)
{
args.Add("-g2 -gdwarf-4");
args.Add("-fno-omit-frame-pointer");
args.Add("-fno-function-sections");
}
switch (Architecture)
{
case TargetArchitecture.x86:
args.Add("-march=atom");
if (Configuration.AndroidPlatformApi < 24)
{
args.Add("-mstackrealign");
}
break;
case TargetArchitecture.x64:
args.Add("-march=atom");
break;
case TargetArchitecture.ARM:
args.Add("-march=armv7-a");
args.Add("-mfloat-abi=softfp");
args.Add("-mfpu=vfpv3-d16");
break;
case TargetArchitecture.ARM64:
args.Add("-march=armv8-a");
break;
default: throw new InvalidArchitectureException(Architecture);
}
}
/// <inheritdoc />
public override void PreBuild(TaskGraph graph, BuildOptions buildOptions)
{
// If building engine executable for platform doesn't support referencing it when linking game shared libraries
if (UseSymbolsExports && OutputType == TargetOutputType.Executable && !buildOptions.Platform.HasExecutableFileReferenceSupport)
{
// Don't link Main module into shared library
Modules.Remove("Main");
}
base.PreBuild(graph, buildOptions);
}
public static void IgnoreNotIncluded(this TaskGraph graph, IReadOnlyCollection <string> included)
{
if (included.None())
{
return;
}
foreach (var m in graph.All.Where(m => !included.Contains(m.Name)))
{
m.Status = Ignored;
}
}
/// <inheritdoc />
public override void PreBuild(TaskGraph graph, BuildOptions buildOptions)
{
// If building engine executable for platform doesn't support referencing it when linking game shared libraries
if (UseSeparateMainExecutable(buildOptions))
{
// Don't link Main module into shared library
Modules.Remove("Main");
}
base.PreBuild(graph, buildOptions);
}
/// <inheritdoc />
protected override void SetupCompileCppFilesArgs(TaskGraph graph, BuildOptions options, List <string> args)
{
base.SetupCompileCppFilesArgs(graph, options, args);
if (options.CompileEnv.WinRTComponentExtensions)
{
foreach (var path in _usingDirs)
{
args.Add(string.Format("/AI\"{0}\"", path));
}
}
}
/// <inheritdoc />
protected override Task CreateBinary(TaskGraph graph, BuildOptions options, string outputFilePath)
{
// Bundle STL library for the executable files for runtime
if (options.LinkEnv.Output == LinkerOutput.Executable)
{
graph.AddCopyFile(Path.Combine(Path.GetDirectoryName(outputFilePath), "libc++_shared.so"), Path.Combine(AndroidNdk.Instance.RootPath, "sources/cxx-stl/llvm-libc++/libs/", GetAbiName(Architecture), "libc++_shared.so"));
}
var task = base.CreateBinary(graph, options, outputFilePath);
task.CommandPath = ClangPath;
return(task);
}
/// <summary>
/// Links the files into an archive (static library).
/// </summary>
protected virtual Task CreateArchive(TaskGraph graph, BuildOptions options, string outputFilePath)
{
var linkEnvironment = options.LinkEnv;
var task = graph.Add <LinkTask>();
// Setup arguments
var args = new List <string>();
{
args.Add("rcs");
args.Add(string.Format("-o \"{0}\"", outputFilePath));
}
SetupArchiveFilesArgs(graph, options, args, outputFilePath);
// Input files
task.PrerequisiteFiles.AddRange(linkEnvironment.InputFiles);
foreach (var file in linkEnvironment.InputFiles)
{
args.Add(string.Format("\"{0}\"", file.Replace('\\', '/')));
}
// Use a response file (it can contain any commands that you would specify on the command line)
bool useResponseFile = true;
string responseFile = null;
if (useResponseFile)
{
responseFile = Path.Combine(options.IntermediateFolder, Path.GetFileName(outputFilePath) + ".response");
task.PrerequisiteFiles.Add(responseFile);
Utilities.WriteFileIfChanged(responseFile, string.Join(Environment.NewLine, args));
}
// Link object into archive
task.WorkingDirectory = options.WorkingDirectory;
task.CommandPath = ArPath;
task.CommandArguments = useResponseFile ? string.Format("@\"{0}\"", responseFile) : string.Join(" ", args);
task.Cost = task.PrerequisiteFiles.Count;
task.ProducedFiles.Add(outputFilePath);
// Generate an index to the contents of an archive
/*task = graph.Add<LinkTask>();
* task.CommandPath = RanlibPath;
* task.CommandArguments = string.Format("\"{0}\"", outputFilePath);
* task.InfoMessage = "Linking " + outputFilePath;
* task.PrerequisiteFiles.Add(outputFilePath);
* task.ProducedFiles.Add(outputFilePath);*/
return(task);
}
/// <inheritdoc />
public override void PreBuild(TaskGraph graph, BuildOptions options)
{
base.PreBuild(graph, options);
// Compile and include resource file if need to
if (options.Target.Win32ResourceFile != null && !options.Target.IsPreBuilt && options.Target.OutputType == TargetOutputType.Executable)
{
var task = graph.Add <CompileCppTask>();
var args = new List <string>();
var sourceFile = options.Target.Win32ResourceFile;
// Suppress Startup Banner
args.Add("/nologo");
// Language
args.Add("/l 0x0409");
// Add preprocessor definitions
foreach (var definition in options.CompileEnv.PreprocessorDefinitions)
{
args.Add(string.Format("/D \"{0}\"", definition));
}
// Add include paths
foreach (var includePath in options.CompileEnv.IncludePaths)
{
AddIncludePath(args, includePath);
}
// Add the resource file to the produced item list
var outputFile = Path.Combine(options.IntermediateFolder, Path.GetFileNameWithoutExtension(sourceFile) + ".res");
args.Add(string.Format("/Fo\"{0}\"", outputFile));
options.LinkEnv.InputFiles.Add(outputFile);
// Request included files to exist
var includes = IncludesCache.FindAllIncludedFiles(sourceFile);
task.PrerequisiteFiles.AddRange(includes);
// Add the source file
args.Add(string.Format("\"{0}\"", sourceFile));
task.ProducedFiles.Add(outputFile);
task.WorkingDirectory = options.WorkingDirectory;
task.CommandPath = _resourceCompilerPath;
task.CommandArguments = string.Join(" ", args);
task.PrerequisiteFiles.Add(sourceFile);
task.Cost = 1;
}
}
static void Main(string[] args)
{
int count = 10;
Data data = new Data();
TaskStep0[] step0 = new TaskStep0[count];
TaskStep1[] step1 = new TaskStep1[count];
TaskStep2[] step2 = new TaskStep2[count];
for (int index = 0; index < count; index++)
{
step0[index] = new TaskStep0(data, index, count);
step1[index] = new TaskStep1(data, index, count);
step2[index] = new TaskStep2(data, index, count);
}
TaskEvent event1 = new TaskEvent();
TaskEvent event2 = new TaskEvent();
TaskGraph taskGraph = new TaskGraph();
taskGraph.Create(8);
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
if (key.Key != ConsoleKey.Escape)
{
Console.WriteLine("");
for (int index = 0; index < count; index++)
{
taskGraph.Task(step0[index], event1, null);
taskGraph.Task(step1[index], event2, event1);
taskGraph.Task(step2[index], null, event2);
}
taskGraph.Dispatch();
taskGraph.Wait();
continue;
}
break;
}
taskGraph.Destroy();
}
/// <inheritdoc />
public override void PostBuild(TaskGraph graph, BuildOptions buildOptions)
{
base.PostBuild(graph, buildOptions);
// If building engine executable for platform doesn't support referencing it when linking game shared libraries
if (UseSymbolsExports && OutputType == TargetOutputType.Executable && !buildOptions.Platform.HasExecutableFileReferenceSupport)
{
// Build additional executable with Main module only that uses shared library
using (new ProfileEventScope("BuildExecutable"))
{
BuildMainExecutable(graph, buildOptions);
}
// Restore state from PreBuild
Modules.Add("Main");
}
}
public async Task TestGraphRunner()
{
var ctx = await TestSetup.TextCtx();;
var res = await TaskGraph.FromMethods(
(l, c) => Shorten(l),
(l, c) => Generate(l, true),
(l, c) => NotDependent(l))
.Run(parallel: 2, ctx.Log, CancellationToken.None);
var resByName = res.ToKeyedCollection(r => r.Name);
resByName[nameof(Generate)].FinalStatus.Should().Be(GraphTaskStatus.Error);
resByName[nameof(Shorten)].FinalStatus.Should().Be(GraphTaskStatus.Cancelled);
resByName[nameof(NotDependent)].FinalStatus.Should().Be(GraphTaskStatus.Success);
ctx.Log.Information("Res {Res}, Shortened {Values}", res.Join("\n"), shortened);
}
public async Task Run(IReadOnlyCollection <string> include, ILogger log, CancellationToken cancel = default)
{
var taskGraph = TaskGraph.FromMethods((l, c) => TopVideos(l), (l, c) => TopChannelVideos(l), (l, c) => ChannelStats(l));
taskGraph.IgnoreNotIncluded(include);
var(res, dur) = await taskGraph.Run(parallel : 4, log, cancel).WithDuration();
var errors = res.Where(r => r.Error).ToArray();
if (errors.Any())
{
Log.Error("Index - failed in {Duration}: {@TaskResults}", dur.HumanizeShort(), res.Join("\n"));
}
else
{
Log.Information("Index - completed in {Duration}: {TaskResults}", dur.HumanizeShort(), res.Join("\n"));
}
}
public IActionResult Add([FromBody] TaskGraphAddModel taskGraph)
{
var userList = new List <Guid>();
userList.Add(taskGraph.UserId);
var tgModel = new TaskGraph
{
Id = Guid.NewGuid(),
Description = taskGraph.Description,
Name = taskGraph.Name,
RootId = null,
TaskSetId = null,
ActiveUsers = userList,
WorkspaceId = taskGraph.WorkspaceId
};
return(Ok(ServiceFactory.TaskGraphService.Add(tgModel)));
}
/// <inheritdoc />
protected override void SetupLinkFilesArgs(TaskGraph graph, BuildOptions options, List <string> args, string outputFilePath)
{
base.SetupLinkFilesArgs(graph, options, args, outputFilePath);
args.Add("-shared");
args.Add("-no-canonical-prefixes");
args.Add("-Wl,-Bsymbolic");
args.Add("-Wl,--build-id=sha1");
args.Add("-Wl,-gc-sections");
if (options.LinkEnv.Output == LinkerOutput.Executable)
{
args.Add("-u ANativeActivity_onCreate");
}
string target;
switch (Architecture)
{
case TargetArchitecture.x86:
target = "i686-none-linux-android";
break;
case TargetArchitecture.x64:
target = "x86_64-none-linux-android";
break;
case TargetArchitecture.ARM:
target = "armv7-none-linux-androideabi";
break;
case TargetArchitecture.ARM64:
target = "aarch64-none-linux-android";
break;
default: throw new InvalidArchitectureException(Architecture);
}
var toolchain = ToolsetRoot.Replace('\\', '/');
args.Add(string.Format("--sysroot=\"{0}/sysroot\"", toolchain));
args.Add(string.Format("--gcc-toolchain=\"{0}\"", toolchain));
args.Add("--target=" + target + Configuration.AndroidPlatformApi);
}
public MainWindowViewModel()
{
Graph = new TaskGraph(true);
Graph2 = new SystemGraph(true);
//Add Layout Algorithm Types
layoutAlgorithmTypes.Add("BoundedFR");
layoutAlgorithmTypes.Add("Circular");
layoutAlgorithmTypes.Add("CompoundFDP");
layoutAlgorithmTypes.Add("EfficientSugiyama");
layoutAlgorithmTypes.Add("FR");
layoutAlgorithmTypes.Add("ISOM");
layoutAlgorithmTypes.Add("KK");
layoutAlgorithmTypes.Add("LinLog");
layoutAlgorithmTypes.Add("Tree");
//Pick a default Layout Algorithm Type
LayoutAlgorithmType = "Tree";
}
public IEnumerable <Job> GetJobOrder(TaskGraph graph)
{
var taskOrder = new List <Job>();
var order = new SortedList <long, Job>(new DuplicateKeyComparer <long>());
var critPath = new Dictionary <Job, long>();
foreach (var finishTask in graph.FinishTasks)
{
fillCriticalPath(finishTask, 0, critPath);
}
foreach (var kvp in critPath)
{
var job = kvp.Key;
var crit = kvp.Value;
order.Add(crit, job);
}
return(order.Select(kvp => kvp.Value).Reverse());
}
public async Task TestGraphRunner()
{
using var log = Setup.CreateTestLogger();
log.Information("hey there");
var res = await TaskGraph.FromMethods(
c => Shorten(log),
c => Generate(log, true),
c => NotDependent(log))
.Run(parallel: 2, log, CancellationToken.None);
var resByName = res.ToKeyedCollection(r => r.Name);
resByName[nameof(Generate)].FinalStatus.Should().Be(GraphTaskStatus.Error);
resByName[nameof(Shorten)].FinalStatus.Should().Be(GraphTaskStatus.Cancelled);
resByName[nameof(NotDependent)].FinalStatus.Should().Be(GraphTaskStatus.Success);
log.Information("Res {Res}, Shortened {Values}", res.Join("\n"), shortened);
}
private static void Start()
{
List <Task> tasks = new List <Task>();
ForgeSetup setup = new ForgeSetup();
foreach (PathDescriptor path in Application.GetPluginList())
{
Plugin plugin = new Plugin(path);
plugin.Child = setup;
plugins.Add(plugin);
tasks.Add(plugin);
}
if (tasks.Count == 0)
{
tasks.Add(setup);
}
TaskGraph.AwaitCompletion(tasks);
Application.ProcessLogMessages();
}
/// <inheritdoc />
protected override void SetupCompileCppFilesArgs(TaskGraph graph, BuildOptions options, List <string> args, string outputPath)
{
base.SetupCompileCppFilesArgs(graph, options, args, outputPath);
// Hide all symbols by default
args.Add("-fvisibility-inlines-hidden");
args.Add("-fvisibility-ms-compat");
args.Add(string.Format("-target {0}", ArchitectureName));
args.Add(string.Format("--sysroot=\"{0}\"", ToolsetRoot.Replace('\\', '/')));
if (Architecture == TargetArchitecture.x64)
{
args.Add("-mssse3");
}
if (options.LinkEnv.Output == LinkerOutput.SharedLibrary)
{
args.Add("-fPIC");
}
}
public void ReLayoutGraph()
{
graph = new TaskGraph(true);
NotifyPropertyChanged("Graph");
}
private void generateButton_Click(object sender, RoutedEventArgs e)
{
Random r = new Random();
int nodeMinWeight = 1,
nodeMaxWeight = 5,
nodesNumber = 15,
vertexWeight = 0,
sumGraphWeight = 0;
double coherence = 0.9;
stats.Text += "coherence = " + coherence + "\n";
TaskGraph graph = new TaskGraph(true);
for (int i = 0; i < nodesNumber; i++)
{
vertexWeight = r.Next(nodeMinWeight, nodeMaxWeight);
sumGraphWeight += vertexWeight;
graph.AddVertex(new TaskVertex("V" + i, vertexWeight.ToString()));
}
int edgesWeight = (int)(sumGraphWeight * (1.0 / coherence - 1));
int averageEdgeWeight = edgesWeight / r.Next(nodesNumber, (int)(nodesNumber * 1.2)) + 1;
//int averageEdgeWeight = edgesWeight / r.Next(nodesNumber * (nodesNumber - 1) / 5, nodesNumber * (nodesNumber - 1) / 4 + 1) + 1;
int edgesNumber = 0;
while (edgesWeight > 0 && edgesNumber != nodesNumber * (nodesNumber - 1) / 2)
{
int source = r.Next(nodesNumber - 1);
int target = r.Next(source + 1, nodesNumber);
int weight = r.Next(averageEdgeWeight / 3, (int)(averageEdgeWeight * 2));
weight = weight > edgesWeight ? edgesWeight : weight;
TaskEdge edge = null;
try
{
edge = (from v in graph.Edges
where v.Source.ID == "V" + source && v.Target.ID == "V" + target
select v).First();
}
catch
{
}
if (edge == null && weight > 0)
{
var sourceVertex = graph.Vertices.Where(node => node.ID == "V" + source).Single();
var targetVertex = graph.Vertices.Where(node => node.ID == "V" + target).Single();
graph.AddEdge(new TaskEdge(weight.ToString(), sourceVertex, targetVertex));
edgesWeight -= weight;
edgesNumber++;
}
}
vm.Graph = graph;
}
//Open Graph
private void LoadGraph_OnClick(object sender, RoutedEventArgs e)
{
FileDialog dialog = new OpenFileDialog();
dialog.DefaultExt = ".xml";
dialog.Filter = "XML Documents (.xml)|*.xml";
bool? result = dialog.ShowDialog();
if (result != true)
{
return;
}
string path = dialog.FileName;
TaskGraph graph = new TaskGraph(true);
XmlDocument document = new XmlDocument();
document.LoadXml(File.ReadAllText(path));
XmlNodeList vertices = document.GetElementsByTagName("vertice");
XmlNodeList edges = document.GetElementsByTagName("edge");
foreach (XmlNode node in vertices)
{
TaskVertex vertex = new TaskVertex(node.Attributes[0].Value, node.Attributes[1].Value);
graph.AddVertex(vertex);
}
foreach (XmlNode node in edges)
{
var source = graph.Vertices.First(x => x.ID == node.Attributes[1].Value);
var target = graph.Vertices.First(x => x.ID == node.Attributes[2].Value);
TaskEdge edge = new TaskEdge(node.Attributes[0].Value, source, target);
graph.AddEdge(edge);
}
vm.Graph = graph;
}
