public virtual uint[] FromAsmSource(string asmSource) { // making a API call to integration server. if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { // on Windows, integration server is required to run in Docker or WSL. // Installation steps are same for WSL and for docker. // https://github.com/EvgenyMuryshkin/Quokka.RISCV.Docker/blob/master/Dockerfile var instructions = RISCVIntegrationClient.Asm(new RISCVIntegrationEndpoint(), asmSource); return(instructions.Result); } else { // on Linux, just make local call to RISCV toolchain return(RISCVIntegrationClient.ToInstructions(Toolchain.Asm(asmSource)).ToArray()); } }
public static IEnumerable <AssembledInstruction> AssembleSource(Toolchain.Configuration tcConfig, string source, AssembleSourceOptions options = null) { var assembled = GetChunksWithCommon(source) .Select(x => new { x.Assembly, x.RomAddress, x.RamAddress, Out = Toolchain.Assemble(tcConfig, x.Assembly) }) .ToArray(); var linkerParts = assembled.Select(x => (x.Out.Path, x.RamAddress)); var linkerDetails = Toolchain.GenerateLinkerScript(linkerParts); using (var elf = Toolchain.Link(tcConfig, new[] { "-q" }, linkerDetails.script)) { try { return(linkerDetails.chunkFilter .Zip(assembled, (filter, asm) => new { filter, asm.RamAddress, asm.RomAddress }) .SelectMany(x => Toolchain.ToBinary(tcConfig, elf.Path, x.filter.SelectMany(y => new[] { "-j", y })) .ToInstructions() .Select((y, i) => new AssembledInstruction(x.RomAddress + (uint)i * 4, x.RamAddress + (uint)i * 4, y)) ) .ToArray()); } finally { foreach (var x in assembled) { x.Out.Dispose(); } if (options?.PreserveElfAt != null) { File.Copy(elf.Path, options.PreserveElfAt, true); } } } }
public void CustomToolchainsAreSupported() { var logger = new OutputLogger(Output); var generator = new MyGenerator(); var builder = new MyBuilder(); var executor = new MyExecutor(); var myToolchain = new Toolchain("My", generator, builder, executor); var job = new Job(Job.Dry) { Infrastructure = { Toolchain = myToolchain } }; var config = CreateSimpleConfig(logger).With(job); CanExecute <ToolchainBenchmark>(config, fullValidation: false); Assert.True(generator.Done); Assert.True(builder.Done); Assert.True(executor.Done); }
public ActionResult Invoke([FromBody] BaseRequest request) { try { switch (request) { case InvokeRequest invoke: return(Ok(Toolchain.Invoke(invoke))); default: return(BadRequest($"Unsupported request type: {request.GetType()}")); } } catch (Exception ex) { Console.WriteLine(ex); return(BadRequest(ex.ToString())); } }
public void AllFilesTest() { var id = Guid.NewGuid(); using (var tc = new Toolchain(id)) { tc.SetupRules(new [] { new AllFilesRule() }); File.WriteAllText(Path.Combine(tc.RootPath, "1.txt"), "content"); File.WriteAllBytes(Path.Combine(tc.RootPath, "1.bin"), new byte[] { 128 }); var classes = new ExtensionClasses().Text("txt").Binary("bin"); var result = tc.LoadSnapshot(classes); Assert.AreEqual(2, result.Files.Count); Assert.AreEqual(1, result.Files.OfType <FSTextFile>().Count()); Assert.AreEqual(1, result.Files.OfType <FSBinaryFile>().Count()); } }
private static BenchmarkReport Run(Benchmark benchmark, ILogger logger, IConfig config, string rootArtifactsFolderPath) { var toolchain = Toolchain.GetToolchain(benchmark.Job); logger.WriteLineHeader("// **************************"); logger.WriteLineHeader("// Benchmark: " + benchmark.ShortInfo); var generateResult = Generate(logger, toolchain, benchmark, rootArtifactsFolderPath, config); try { if (!generateResult.IsGenerateSuccess) { return(new BenchmarkReport(benchmark, generateResult, null, null, null)); } var buildResult = Build(logger, toolchain, generateResult, benchmark); if (!buildResult.IsBuildSuccess) { return(new BenchmarkReport(benchmark, generateResult, buildResult, null, null)); } List <ExecuteResult> executeResults = Execute(logger, benchmark, toolchain, buildResult, config); var runs = new List <Measurement>(); for (int index = 0; index < executeResults.Count; index++) { var executeResult = executeResults[index]; runs.AddRange(executeResult.Data.Select(line => Measurement.Parse(logger, line, index + 1)).Where(r => r != null)); } return(new BenchmarkReport(benchmark, generateResult, buildResult, executeResults, runs)); } finally { Cleanup(generateResult.DirectoryPath, config); } }
public void SaveSnapshot() { using (var tc = new Toolchain(Guid.NewGuid())) { var fs = new FSSnapshot(); fs.Files.Add(new FSTextFile() { Name = "1.txt", Content = "abc" }); fs.Files.Add(new FSBinaryFile() { Name = "1.bin", Content = new byte[] { 128 } }); tc.SaveSnapshot(fs); Assert.AreEqual("abc", File.ReadAllText(Path.Combine(tc.RootPath, "1.txt"))); Assert.AreEqual(128, File.ReadAllBytes(Path.Combine(tc.RootPath, "1.bin"))[0]); } }
public void ExecuteCommandTest_Success() { using (var tc = new Toolchain(Guid.NewGuid())) { var fs = new FSSnapshot(); fs.Files.Add(new FSTextFile() { Name = "1.cmd", Content = "copy 1.txt 2.txt" }); fs.Files.Add(new FSTextFile() { Name = "1.txt", Content = "content" }); tc.SaveSnapshot(fs); tc.SetupRules(new[] { new ModifiedFilesRule() }); tc.Invoke(new[] { new CommandLineInfo() { FileName = "cmd.exe", Arguments = "/c 1.cmd" } }); var result = tc.LoadSnapshot(new ExtensionClasses().Text("txt")); Assert.AreEqual(1, result.Files.Count); var file = (FSTextFile)result.Files[0]; Assert.AreEqual("2.txt", file.Name); Assert.AreEqual("content", file.Content); } }
private static Benchmark[] GetSupportedBenchmarks(IList <Benchmark> benchmarks, CompositeLogger logger) { return(benchmarks.Where(benchmark => Toolchain.GetToolchain(benchmark.Job).IsSupported(benchmark, logger)).ToArray()); }
public void Benchmark() { Console.WriteLine($"{AvoidParsingException} {Toolchain.GetToolchain(Runtime.Host)}"); }
/// <inheritdoc /> void IVisualStudioProjectCustomizer.WriteVisualStudioBuildProperties(VisualStudioProject project, Platform platform, Toolchain toolchain, Project.ConfigurationData configuration, StringBuilder vcProjectFileContent, StringBuilder vcFiltersFileContent, StringBuilder vcUserFileContent) { // Override the debugger to use Editor if target doesn't output executable file var outputType = project.OutputType ?? configuration.Target.OutputType; if (outputType != TargetOutputType.Executable && configuration.Name.StartsWith("Editor.")) { var editorFolder = configuration.Architecture == TargetArchitecture.x64 ? "Win64" : "Win32"; vcUserFileContent.AppendLine(string.Format(" <PropertyGroup Condition=\"'$(Configuration)|$(Platform)'=='{0}'\">", configuration.Name)); vcUserFileContent.AppendLine(string.Format(" <LocalDebuggerCommand>{0}\\FlaxEditor.exe</LocalDebuggerCommand>", Path.Combine(Globals.EngineRoot, "Binaries", "Editor", editorFolder, configuration.ConfigurationName))); vcUserFileContent.AppendLine(" <LocalDebuggerCommandArguments>-project \"$(SolutionDir)\" -skipCompile</LocalDebuggerCommandArguments>"); vcUserFileContent.AppendLine(" <LocalDebuggerWorkingDirectory>$(SolutionDir)</LocalDebuggerWorkingDirectory>"); vcUserFileContent.AppendLine(" <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>"); vcUserFileContent.AppendLine(" </PropertyGroup>"); } }
public bool Exec(CheckoutCommandOptions options) { Toolchain.RequireSubversion(); bool ok; if (!options.Repository.On) { return(Prompt.PrintInvalidUsage("A URI do repositório Subversion não foi indicada.")); } var revision = options.Revision.On ? options.Revision.Text : "HEAD"; var user = options.User.On ? options.User.Text : Svn.DefaultUser; var pass = options.Pass.On ? options.Pass.Text : Svn.DefaultPass; var folder = options.Directory.On ? options.Directory.Text : "."; folder = Path.GetFullPath(folder); if (!Directory.Exists(folder)) { Directory.CreateDirectory(folder); } Prompt.PrintInfo("Workcopy: \n" + folder); var workcopy = new SvnWorkcopy(folder, user, pass); var remote = new SvnRemote(user, pass); var tag = GetTagName(options); if (tag == "latest") { var baseUri = options.Repository.Text; var tagNames = remote.GetTagNames(baseUri, revision); var tagName = SemVer.GetMaxVersion(tagNames); if (tagName == null) { var exists = remote.HasSpecialFolder(baseUri, revision, "trunk"); tagName = exists ? "trunk" : "self"; } tag = tagName; } var uri = GetRepositoryUri(options, tag); var workcopyUri = workcopy.GetInfo(Properties.Url); if (options.ForceCheckout.On || uri != workcopyUri) { workcopy.PurgeWorkcopy(); ok = workcopy.Checkout(uri, revision); if (!ok) { return(Prompt.PrintCannotContinue()); } ok = workcopy.Cleanup(); if (!ok) { return(Prompt.PrintCannotContinue()); } } else { ok = workcopy.Cleanup(); if (!ok) { return(Prompt.PrintCannotContinue()); } ok = workcopy.Revert(); if (!ok) { return(Prompt.PrintCannotContinue()); } ok = workcopy.Cleanup(); if (!ok) { return(Prompt.PrintCannotContinue()); } ok = workcopy.Update(revision); if (!ok) { return(Prompt.PrintCannotContinue()); } } workcopy.ShowInfo(); Prompt.PrintInfo("Concluído com êxito."); return(true); }
public bool Exec(UpgradeToolchainCommandOptions options) { Toolchain.RequireAll(force: true); return(true); }
public void B() { Console.WriteLine($"{Toolchain.GetToolchain(Runtime.Host)}"); }
public bool Exec(BuildCommandOptions options) { Toolchain.RequireDevenv(); Toolchain.RequirePackDm(); Toolchain.RequireSubversion(); bool ok; string[] solutions; if (options.Solutions.On) { solutions = options.Solutions.Items.FindFiles(); } else { solutions = "*.sln".FindFiles(); } if (!solutions.Any()) { return(Prompt.PrintNothingToBeDone("Nenhuma solução detectada.")); } var pack = new Library.PackDm.PackDm(); pack.PackConf = options.ConfFile.Text; pack.PackInfo = options.PackFile.Text; var svn = new Svn(); ok = pack.Fill(); if (!ok) { return(Prompt.PrintCannotContinue()); } ok = svn.Fill(); if (!ok) { return(Prompt.PrintCannotContinue()); } // Imprimindo informação de revisao do pack.info e do subverison // no console e no arquivo REVISION.txt VersionInfo version; { var revisionFilepath = Path.GetFullPath("REVISION.txt"); var loader = new ProjectLoader(); loader.PackConf = options.ConfFile.Text; loader.PackInfo = options.PackFile.Text; var ret = loader.LoadProjectHeader(); if (!ret.Ok) { return(Prompt.PrintCannotContinue()); } var project = ret.Value; version = project.Version; // imprimindo no console e no arquivo Prompt.PrintInfo(version); File.WriteAllText(revisionFilepath, version); } var configuration = options.Configuration.Text ?? "Release|Any CPU"; foreach (var solution in solutions) { var solutionFilename = Path.GetFileName(solution); var solutionFolder = Path.GetDirectoryName(solution); ok = $"devenv.com {solution.Quote()} /Rebuild {configuration.Quote()}".Run(); if (!ok) { return(Prompt.PrintCannotContinue()); } } // O packDm usa a máscara para substituir partes da versao var versionMask = $"*.*.*{version.FormattedPreRelease}"; ok = pack.Pack(versionMask); if (!ok) { return(Prompt.PrintCannotContinue()); } // Constrói a página HTML com informações de setup. // Falhas podem ser ignoradas. var title = Path.GetFileName(solutions.First()).Replace(".sln", ""); MakeSetupPage(title, version); return(true); }