public void ShouldExecuteAllTasksInOrder() { var commands = new Mock <IProgramCommand>[] { new Mock <IProgramCommand>(), new Mock <IProgramCommand>(), new Mock <IProgramCommand>() }; int j = 0; for (int i = 0; i < commands.Length; ++i) { // I cannot reference 'i' inside Callback because it will have always value 3 inside callback. // It's always referencing the same thing inside callback. meh // I need to create local variable - oh gosh. int a = i; commands[i].Setup(x => x.Execute(robotMock.Object)).Callback(() => Assert.Equal(j++, a)); } programMock.SetupGet(x => x.Commands).Returns(commands.Select(x => x.Object)); var exec = new ProgramExecutor(programMock.Object, robotMock.Object); exec.Start(); Thread.Sleep(1000); Assert.True(exec.IsCompleted); }
public void ExecuteProgram_ReadsInCorrectly(int[] program, int positionValue, int inputValue) { mockWriter.Setup(mw => mw.ReadLine()).Returns("2"); programExecutor = new ProgramExecutor(mockWriter.Object); var output = programExecutor.ExecuteProgram(program); Assert.Equal(inputValue, output[positionValue]); }
private static void RemoveFixedPrograms(FuzzlynOptions options, string dir) { string[] files = Directory.GetFiles(dir, "*.cs"); List <ulong> toRereduce = new List <ulong>(); for (int i = 0; i < files.Length; i++) { Console.Title = $"Processing {i + 1}/{files.Length}"; string contents = File.ReadAllText(files[i]); MatchCollection matches = Regex.Matches(contents, "// Seed: ([0-9]+)"); if (matches.Count != 1) { continue; } ulong seed = ulong.Parse(matches[0].Groups[1].Value); options.Seed = seed; var cg = new CodeGenerator(options); CompilationUnitSyntax original = cg.GenerateProgram(false); CompileResult debug = Compiler.Compile(original, Compiler.DebugOptions); CompileResult release = Compiler.Compile(original, Compiler.ReleaseOptions); if (debug.CompileErrors.Length > 0 || release.CompileErrors.Length > 0) { continue; } if (debug.RoslynException != null || release.RoslynException != null) { continue; } ProgramPairResults execResults = ProgramExecutor.RunPair(new ProgramPair(debug.Assembly, release.Assembly)); if (execResults.DebugResult.Checksum != execResults.ReleaseResult.Checksum || execResults.DebugResult.ExceptionType != execResults.ReleaseResult.ExceptionType) { // Execute the reduced form to see if we get interesting behavior. // Otherwise we may need to rereduce it. if (!IsReducedVersionInteresting(execResults, contents)) { toRereduce.Add(seed); Console.WriteLine("Marking {0} for rereduction", Path.GetFileName(files[i])); } continue; } Console.WriteLine("Removing {0}", Path.GetFileName(files[i])); File.Delete(files[i]); } const string rereduceFile = "Rereduce_required.txt"; File.WriteAllText(rereduceFile, string.Join(Environment.NewLine, toRereduce)); Console.WriteLine("Wrote {0} seeds to be rereduced to '{1}'", toRereduce.Count, Path.GetFullPath(rereduceFile)); }
public void ExecuteProgram_OutputsCorrectDiagnosticsCode(int[] program, string readLineOutput, string expectedOutput) { mockWriter.Setup(mw => mw.ReadLine()).Returns(readLineOutput); programExecutor = new ProgramExecutor(mockWriter.Object); var output = programExecutor.ExecuteProgram(program); mockWriter.Verify(mw => mw.Write(It.Is <string>(s => s.Equals(expectedOutput)))); }
public void RunGalaxy() { var declarations = File.ReadAllLines("galaxy.txt"); var main = "ap galaxy ap ap cons 0 146"; var executor = new ProgramExecutor(); var result = executor.Execute(main, declarations); TestContext.Progress.WriteLine(result.PrettyPrint()); }
private List <Command> GetProgramCommands(JSProgram program) { (CDFG cdfg, _) = TestTools.ParseProgram(program); TestCommandExecutor executor = new TestCommandExecutor(); ProgramExecutor <string> programExecutor = new ProgramExecutor <string>(executor); programExecutor.TimeBetweenCommands = 0; programExecutor.ShowEmptyRectangles = false; programExecutor.Run(10, 10, cdfg, false); return(executor.Commands); }
private async void Window_Loaded(object sender, RoutedEventArgs e) { CompilerOptions.PROGRAM_FOLDER_PATH = PROGRAMS_FOLDER_PATH; var programData = InlineProgram.LoadProgram("Basic protocol for E. coli Quick"); //var programData = InlineProgram.LoadProgram("showcasing using inline program block"); //var programData = InlineProgram.LoadProgram("UsingDiluter3"); var sassdad = XmlParser.Parse("<xml xmlns='http://www.w3.org/1999/xhtml'><variables><variable type='' id='gZ,c_HQgu:,yfA:J+Lxt'>input_fluid_name</variable></variables><block type='start' id='7skRs`d%@XtBz=rV_7{/' x='528' y='219'><statement name='program'><block type='inputDeclaration' id='2lbQ[al;v|T3G{$fy9Tn'><field name='inputName' id='gZ,c_HQgu:,yfA:J+Lxt' variabletype=''>asd</field><field name='inputAmount'>1</field></block></statement></block></xml>"); for (int i = 0; i < 1; i++) { BenchmarkExecutor executor = new BenchmarkExecutor(); ProgramExecutor <string> CurrentlyExecutionProgram = new ProgramExecutor <string>(executor); CurrentlyExecutionProgram.TimeBetweenCommands = 0; CurrentlyExecutionProgram.ShowEmptyRectangles = false; CurrentlyExecutionProgram.EnableOptimizations = true; CurrentlyExecutionProgram.EnableGarbageCollection = true; CurrentlyExecutionProgram.EnableSparseElectrodes = false; CurrentlyExecutionProgram.Run(45, 45, programData.cdfg, false); } this.Close(); //Run in another thread to not block the UI await Task.Run(() => { SettingsInfo settings = new SettingsInfo(); settings.LoadSettings(SETTINGS_FILE_PATH); this.Updater = new WebUpdater(Browser, settings); Browser.Load("costum://index.html"); Browser.JavascriptObjectRepository.Register("saver", new Saver(Browser), true); Browser.JavascriptObjectRepository.Register("webUpdater", Updater, true); //Wait for the MainFrame to finish loading Browser.FrameLoadEnd += async(s, args) => { //Wait for the MainFrame to finish loading if (args.Frame.IsMain) { //Run in another thread to not block the UI await Task.Run(() => { GiveSettingsToJS(settings); GiveProgramsToJS(); }); } }; }); }
public void Test() { var add4 = "add4 = ap add ap add ap add ap add 4"; var main = "ap add4 8 5 5 5 5 5 3 3 3"; var fff = "fff = ap t fff"; var main1 = "ap fff 42"; var executor = new ProgramExecutor(); var result = executor.Execute(main, add4); //var result = executor.Execute(main1, fff);N Console.WriteLine(result.PrettyPrint()); Console.WriteLine(result.Print()); Console.WriteLine(AstReducer.ReducesCount); }
private ProgramPairResults CompileAndRun(CompilationUnitSyntax prog) { CompileResult progDebug = Compiler.Compile(prog, Compiler.DebugOptions); CompileResult progRelease = Compiler.Compile(prog, Compiler.ReleaseOptions); if (progDebug.Assembly == null || progRelease.Assembly == null) { return(null); } ProgramPair pair = new ProgramPair(progDebug.Assembly, progRelease.Assembly); ProgramPairResults results = ProgramExecutor.RunPair(pair); return(results); }
private void RunSimulator(CDFG cdfg, bool alreadyOptimized) { lock (simulatorLocker) { if (CurrentlyExecutionProgram != null) { CurrentlyExecutionProgram.KeepRunning.Cancel(); } simulatorThread?.Join(); simulatorThread = new Thread(() => { try { int boardWidth = Settings.BoardWidth; int boardHeight = Settings.BoardHeight; int timeBetweenCommands = (int)((1f / Settings.CommandFrequency) * 1000); using (SimulatorConnector executor = new SimulatorConnector(Browser, boardWidth, boardHeight)) { CurrentlyExecutionProgram = new ProgramExecutor<string>(executor); CurrentlyExecutionProgram.TimeBetweenCommands = timeBetweenCommands; CurrentlyExecutionProgram.ShowEmptyRectangles = Settings.ShowEmptyRectangles; CurrentlyExecutionProgram.EnableOptimizations = Settings.EnableOptimizations; CurrentlyExecutionProgram.EnableGarbageCollection = Settings.EnableGC; CurrentlyExecutionProgram.EnableSparseElectrodes = Settings.EnableSparseBoard; CurrentlyExecutionProgram.Run(boardWidth, boardHeight, cdfg, alreadyOptimized); } } catch (InternalRuntimeException e) { Browser.ExecuteScriptAsync($"ShowUnexpectedError(\"{e.Message.Replace('\"', '\'')}\");"); } catch (RuntimeException e) { Browser.ExecuteScriptAsync($"ShowUnexpectedError(\"{e.Message.Replace('\"', '\'')}\");"); } catch (ThreadInterruptedException) { } catch (Exception e) { Debug.WriteLine(e.Message + Environment.NewLine + e.StackTrace); } }); simulatorThread.Start(); } }
private static string BuildAndRun(string filePath) { ILLanguage backend = new CecilBackendLanguage(filePath); using (var interpreter = new Interpreter <ILLanguage>(backend)) using (var source = new StreamReader(filePath)) { if (!interpreter.Parse(source, filePath)) { throw new AssertionException("Parsing of file " + filePath + " failed!"); } } backend.Save(); return(ProgramExecutor.Execute(Path.GetFileNameWithoutExtension(filePath) + ".exe")); }
public void CannotStartSameExecutorTwice() { var commands = new Mock <IProgramCommand>[] { new Mock <IProgramCommand>(), new Mock <IProgramCommand>(), new Mock <IProgramCommand>() }; programMock.SetupGet(x => x.Commands).Returns(commands.Select(x => x.Object)); var exec = new ProgramExecutor(programMock.Object, robotMock.Object); exec.Start(); Assert.Throws <RobotsException>(() => exec.Start()); }
public void ShouldTriggerProperEvents() { var commands = new Mock <IProgramCommand>[] { new Mock <IProgramCommand>(), new Mock <IProgramCommand>(), new Mock <IProgramCommand>() }; int j = 0; for (int i = 0; i < commands.Length; ++i) { commands[i].Setup(x => x.Execute(robotMock.Object)).Callback(() => ++ j); } programMock.SetupGet(x => x.Commands).Returns(commands.Select(x => x.Object)); var exec = new ProgramExecutor(programMock.Object, robotMock.Object); exec.CommandExecutionStart += (_, e) => Assert.Equal(commands[j].Object, e.Command); exec.CommandExecutionEnd += (_, e) => Assert.Equal(commands[j - 1].Object, e.Command); exec.ProgramExecutionEnd += (_, e) => Assert.Equal(commands.Length, j); }
private static void Main(string[] args) { ulong? seed = null; int? numPrograms = null; int? parallelism = null; FuzzlynOptions options = null; bool help = false; bool dumpOptions = false; bool? output = null; bool? executePrograms = null; bool? enableChecksumming = null; bool? reduce = null; bool? reduceInChildProcesses = null; string reduceDebugGitDir = null; string removeFixed = null; bool? stats = null; OptionSet optionSet = new OptionSet { { "seed=|s=", "Seed to use when generating a single program", (ulong v) => seed = v }, { "parallelism=", "Number of cores to use", (int?p) => parallelism = p }, { "num-programs=|n=", "Number of programs to generate", (int v) => numPrograms = v }, { "options=", "Path to options.json. Command-line options will override options from this file.", s => options = JsonConvert.DeserializeObject <FuzzlynOptions>(File.ReadAllText(s)) }, { "dump-options", "Dump options to stdout and do nothing else", v => dumpOptions = v != null }, { "output-source", "Output program source instead of feeding them directly to Roslyn and execution", v => output = v != null }, { "execute-programs", "Accept programs to execute on stdin and report back differences", v => executePrograms = v != null }, { "checksum", "Enable or disable checksumming in the generated code", v => enableChecksumming = v != null }, { "reduce", "Reduce program to a minimal example", v => reduce = v != null }, { "reduce-use-child-processes", "Check reduced example candidates in child processes", v => reduceInChildProcesses = v != null }, { "reduce-debug-git-dir=", "Create reduce path in specified dir (must not exists beforehand)", v => reduceDebugGitDir = v }, { "remove-fixed=", "Remove fixed programs in directory", v => removeFixed = v }, { "stats", "Generate a bunch of programs and record their sizes", v => stats = v != null }, { "help|h", v => help = v != null } }; string error = null; try { List <string> leftover = optionSet.Parse(args); if (leftover.Any()) { error = "Unknown arguments: " + string.Join(" ", leftover); } } catch (OptionException ex) { error = ex.Message; } if (error != null) { Console.WriteLine("Fuzzlyn: {0}", error); Console.WriteLine("Use --help for help."); return; } if (help) { Console.WriteLine("Usage: fuzzlyn.exe"); optionSet.WriteOptionDescriptions(Console.Out); return; } if (executePrograms.HasValue && executePrograms.Value) { ProgramExecutor.Run(); return; } if (options == null) { options = new FuzzlynOptions(); } if (seed.HasValue) { options.Seed = seed.Value; } if (numPrograms.HasValue) { options.NumPrograms = numPrograms.Value; } if (parallelism.HasValue) { options.Parallelism = parallelism.Value; } if (output.HasValue) { options.Output = output.Value; } if (enableChecksumming.HasValue) { options.EnableChecksumming = enableChecksumming.Value; } if (reduce.HasValue) { options.Reduce = reduce.Value; } if (reduceInChildProcesses.HasValue) { options.ReduceWithChildProcesses = reduceInChildProcesses.Value; } if (stats.HasValue) { options.Stats = stats.Value; } if (options.NumPrograms != 1 && options.Seed.HasValue) { Console.WriteLine("Error: Must specify exactly 1 program if a seed is specified."); return; } if (options.Reduce && !options.Seed.HasValue) { Console.WriteLine("Error: Cannot reduce without a seed."); return; } if (dumpOptions) { Console.Write(JsonConvert.SerializeObject(options, Formatting.Indented)); return; } string val = Environment.GetEnvironmentVariable("COMPlus_TieredCompilation"); if (val != "0") { Console.WriteLine( "Please set the COMPlus_TieredCompilation environment variable " + "to \"0\" before starting Fuzzlyn."); Console.WriteLine("For cmd use \"set COMPlus_TieredCompilation=0\"."); Console.WriteLine("For powershell use \"$env:COMPlus_TieredCompilation='0'\""); Console.WriteLine("For bash use \"export COMPlus_TieredCompilation=0\""); Console.WriteLine("For Visual Studio, check the debug tab"); } else if (removeFixed != null) { RemoveFixedPrograms(options, removeFixed); } else if (options.Reduce) { ReduceProgram(options, reduceDebugGitDir); } else if (options.Stats) { GenerateProgramsAndGetStats(options); } else if (options.Output) { GenerateProgramsAndOutput(options); } else { GenerateProgramsAndCheck(options); } if (Debugger.IsAttached) { Console.ReadLine(); } }
private static void RemoveFixedPrograms(FuzzlynOptions options, string dir) { const string rereduceFile = "Rereduce_required.txt"; string[] files = Directory.GetFiles(dir, "*.cs").OrderBy(p => p.ToLowerInvariant()).ToArray(); for (int i = 0; i < files.Length; i++) { Console.Title = $"Processing {i + 1}/{files.Length}"; string contents = File.ReadAllText(files[i]); MatchCollection matches = Regex.Matches(contents, "// Seed: ([0-9]+)"); if (matches.Count != 1) { continue; } ulong seed = ulong.Parse(matches[0].Groups[1].Value); Console.Write("Processing {0}: ", seed); options.Seed = seed; var cg = new CodeGenerator(options); CompilationUnitSyntax original = cg.GenerateProgram(); CompileResult debug = Compiler.Compile(original, Compiler.DebugOptions); CompileResult release = Compiler.Compile(original, Compiler.ReleaseOptions); if (debug.CompileErrors.Length > 0 || release.CompileErrors.Length > 0) { Console.WriteLine("Compiler error"); continue; } if (debug.RoslynException != null || release.RoslynException != null) { Console.WriteLine("Compiler exception"); continue; } ProgramPairResults execResults = ProgramExecutor.RunSeparately( new List <ProgramPair> { new ProgramPair(false, debug.Assembly, release.Assembly) }) ?.Single(); if (execResults == null) { Console.WriteLine("Crashed sub-process, still interesting"); continue; } if (execResults.DebugResult.Checksum != execResults.ReleaseResult.Checksum || execResults.DebugResult.ExceptionType != execResults.ReleaseResult.ExceptionType) { // Execute the reduced form to see if we get interesting behavior. // Otherwise we may need to rereduce it. // HOAX: Currently IsReducedVersionInteresting runs the programs // in our own process, so we are conservative and do not run programs // that may crash us (it is possible that the unreduced example does not // crash, but that the reduced does. if (contents.Contains("Crashes the runtime") || IsReducedVersionInteresting(execResults, contents)) { Console.WriteLine("Still interesting"); } else { File.AppendAllText(rereduceFile, seed + Environment.NewLine); Console.WriteLine("Marked for rereduction"); } continue; } Console.WriteLine("Deleted, no longer interesting"); File.Delete(files[i]); } }
public async void Update(string xml) { try { //xml = xml.Replace("<", "<"); //await JSExecutor.InvokeAsync<string>("alert", xml); //throw new Exception(xml); (CDFG cdfg, List <ParseException> exceptions) = XmlParser.Parse(xml); if (exceptions.Count == 0) { bool optimizedCDFG = false; if (Settings.CreateGraph) { if (ProgramExecutor <string> .CanOptimizeCDFG(cdfg) && Settings.EnableOptimizations) { int boardWidth = Settings.BoardWidth; int boardHeight = Settings.BoardHeight; cancelSource?.Cancel(); cancelSource = new CancellationTokenSource(); CDFG newCdfg = new CDFG(); newCdfg.StartDFG = ProgramExecutor <string> .OptimizeCDFG <string>(boardWidth, boardHeight, cdfg, cancelSource.Token, Settings.EnableGC); newCdfg.AddNode(null, newCdfg.StartDFG); if (cancelSource.IsCancellationRequested) { return; } cdfg = newCdfg; optimizedCDFG = true; } (string nodes, string edges) = SimpleGraph.CDFGToSimpleGraph(cdfg); await JSExecutor.InvokeAsync <string>("setGraph", nodes, edges); } await JSExecutor.InvokeAsync <string>("ClearErrors"); RunSimulator(cdfg, optimizedCDFG); } else { var errorInfos = exceptions.GroupBy(e => e.ID) .Select(e => $"{{id: \"{e.Key}\", message: \"{String.Join(@"\n", e.Select(ee => ee.Message))}\"}}"); await JSExecutor.InvokeAsync <string>("ShowBlocklyErrors", errorInfos.ToArray()); } } catch (ParseException e) { await JSExecutor.InvokeAsync <string>("ShowUnexpectedError", e.Message); Debug.WriteLine(e.Message + Environment.NewLine + e.StackTrace); } catch (Exception e) { await JSExecutor.InvokeAsync <string>("ShowUnexpectedError", e.Message); Debug.WriteLine(e.Message + Environment.NewLine + e.StackTrace); } }
private static void Main(string[] args) { /* * if (args.Length == 0) * { * Console.WriteLine("No input file specified"); * return; * } * * var sourcePath = args[0]; */ var codeEmitter = new HappyPenguinCodeEmitter(); /* * codeEmitter.Emit(OpCode.PushA); * codeEmitter.Emit(OpCode.Load, 0xFF, 0xFF); * codeEmitter.Emit(OpCode.Load, 0xFFFF); * codeEmitter.Emit(OpCode.Load, 0xAF, 0xAF); * codeEmitter.Emit(OpCode.Load, 0xAFAF); * codeEmitter.Emit(OpCode.Return); */ //The # represents the programCounter number of the below program codeEmitter.Emit(OpCode.Nop); //0. codeEmitter.Emit(OpCode.MovReg, (byte)RegisterId.A, 0x44); //1. Set A to 0x44 codeEmitter.Emit(OpCode.DupA, 0xFFAA); //2. Copy the data in A to 0xFFAA in memory codeEmitter.Emit(OpCode.LoadB, 0xFFAA); //3. Copy the data at 0xFFAA from A to B codeEmitter.Emit(OpCode.PushA); //4. Push A's value onto the stack codeEmitter.Emit(OpCode.MovReg, (byte)RegisterId.A, 0x33); //5. Set A to 0x33 codeEmitter.Emit(OpCode.XchangeAB); //6. Exchange the values of A and B codeEmitter.Emit(OpCode.PopA); //7. Pop the stored value of A from the stack back into A codeEmitter.Emit(OpCode.MovReg, (byte)RegisterId.A, 0x22); //8. Set A to 0x22 codeEmitter.Emit(OpCode.CompareReg, (byte)RegisterId.A, (byte)RegisterId.B); //9. Compare A and B codeEmitter.Emit(OpCode.JumpZ, 0xE); //10. Jump to PC=0x if the registers in the previous comparison were equal codeEmitter.Emit(OpCode.DupA, 0xFFAA); //11. Copy the data in A to 0xFFAA in memory codeEmitter.Emit(OpCode.LoadB, 0xFFAA); //12. Copy the data at 0xFFAA from A to B codeEmitter.Emit(OpCode.Jump, 0x9); //13. Jump back to line 0x9 to do comparison again codeEmitter.Emit(OpCode.Nop); //14. Jump target from 10. codeEmitter.Emit(OpCode.Jump, 0x14); //15. Jump to after function codeEmitter.Emit(OpCode.PopA); //16. Retrieve A parameter codeEmitter.Emit(OpCode.Nop); //17. Temporary placeholder codeEmitter.Emit(OpCode.Nop); //18. Temporary placeholder codeEmitter.Emit(OpCode.Return); //19. Return from function codeEmitter.Emit(OpCode.Nop); //20. Jump target from 14. codeEmitter.Emit(OpCode.MovReg, (byte)RegisterId.A, 0x4); //21. Set A to 0x4 codeEmitter.Emit(OpCode.ShiftLeft, (byte)RegisterId.A, 0x2); //22. Do a simple multiply by 4 with shifting codeEmitter.Emit(OpCode.PushA); //23. Store A codeEmitter.Emit(OpCode.PopB); //24. Restore B from stack codeEmitter.Emit(OpCode.ShiftRight, (byte)RegisterId.A, 0x2); //25. Undo the multiply codeEmitter.Emit(OpCode.CompareReg, (byte)RegisterId.A, (byte)RegisterId.B); //26. Compare A and B codeEmitter.Emit(OpCode.JumpZ, 0x1D); //27. Jump to PC=1d if the registers in the previous comparison were equal codeEmitter.Emit(OpCode.Fault, 0x1); //28. Fault with code 0x1 codeEmitter.Emit(OpCode.Nop); //29. Jump target codeEmitter.Emit(OpCode.MovReg, (byte)RegisterId.A, 0x11); //30. Load 0x11 into A as the call target codeEmitter.Emit(OpCode.PushA); //31. Push the A register onto the stack as the call target codeEmitter.Emit(OpCode.Call); //32. Call the function from the address on the stack codeEmitter.Emit(OpCode.Halt); //End of program. Halt. var vmProgram = codeEmitter.GetEmittedCode(); var codeEncoder = new CodeEncoder(); using (var outputFileStream = File.Open("testprogram.🐧", FileMode.Create)) { var outStream = new MemoryStream(); codeEncoder.EncodeCodeToStream(vmProgram, outStream); outStream.Position = 0; var loadedProgram = codeEncoder.ReadCodeFromStream(outStream); outStream.Position = 0; outStream.CopyTo(outputFileStream); } var executor = new ProgramExecutor(vmProgram); executor.InitializeMachine(); executor.ExecuteCode(); //Dump memory /* * for (int i = 0; i < executor.Memory.Length; i++) * { * Console.Write($"{executor.Memory[i]} "); * } */ }
public void ExecuteProgram_CorrectlyParsesProgram(int[] program, int[] expectedOutput) { programExecutor = new ProgramExecutor(mockWriter.Object); Assert.Equal(expectedOutput, programExecutor.ExecuteProgram(program)); }
public CompilationUnitSyntax Reduce() { CompileResult debug = Compiler.Compile(Original, Compiler.DebugOptions); CompileResult release = Compiler.Compile(Original, Compiler.ReleaseOptions); Func <CompilationUnitSyntax, bool> isInteresting; if (debug.RoslynException != null || release.RoslynException != null) { CSharpCompilationOptions opts = debug.RoslynException != null ? Compiler.DebugOptions : Compiler.ReleaseOptions; isInteresting = program => Compiler.Compile(program, opts).RoslynException != null; } else if (debug.CompileErrors.Length > 0 || release.CompileErrors.Length > 0) { CSharpCompilationOptions opts = debug.CompileErrors.Length > 0 ? Compiler.DebugOptions : Compiler.ReleaseOptions; isInteresting = program => { CompileResult recompiled = Compiler.Compile(program, opts); if (recompiled.CompileErrors.Length <= 0) { return(false); } return(recompiled.CompileErrors[0].Id == (debug.CompileErrors.Length > 0 ? debug.CompileErrors[0] : release.CompileErrors[0]).Id); }; } else { var origPair = new ProgramPair(debug.Assembly, release.Assembly); ProgramPairResults origResults = ProgramExecutor.RunPair(origPair); if (origResults.DebugResult.Checksum == origResults.ReleaseResult.Checksum && origResults.DebugResult.ExceptionType == origResults.ReleaseResult.ExceptionType) { throw new InvalidOperationException("Program has no errors"); } isInteresting = prog => { ProgramPairResults results = CompileAndRun(prog); if (results == null) { return(false); } // Do exceptions first because they will almost always change checksum if (origResults.DebugResult.ExceptionType != origResults.ReleaseResult.ExceptionType) { // Must throw same exceptions in debug and release to be bad. return(results.DebugResult.ExceptionType == origResults.DebugResult.ExceptionType && results.ReleaseResult.ExceptionType == origResults.ReleaseResult.ExceptionType); } else { if (results.DebugResult.ExceptionType != origResults.DebugResult.ExceptionType || results.ReleaseResult.ExceptionType != origResults.ReleaseResult.ExceptionType) { return(false); } } return(results.DebugResult.Checksum != results.ReleaseResult.Checksum); }; } // Save original comments as simplification may remove it by removing an unnecessary type. SyntaxTriviaList originalTrivia = Original.GetLeadingTrivia(); Reduced = Original.WithLeadingTrivia(); Reduced = CoarseSimplify(Reduced, isInteresting); List <SyntaxNode> simplifiedNodes = new List <SyntaxNode>(); bool first = true; bool any = true; while (any) { any = false; while (true) { if (!SimplifyOne("Statements", Reduced.DescendantNodes().Where(n => n is StatementSyntax).ToList())) { break; } any = true; } while (true) { if (!SimplifyOne("Expressions", Reduced.DescendantNodes().Where(n => n is ExpressionSyntax).ToList())) { break; } any = true; } while (true) { List <SyntaxNode> members = Reduced.DescendantNodesAndSelf().Where(n => n is MemberDeclarationSyntax || n is CompilationUnitSyntax).ToList(); if (!SimplifyOne("Members", members)) { break; } any = true; } first = false; bool SimplifyOne(string name, List <SyntaxNode> list) { for (int i = 0; i < 2000; i++) { Console.Title = $"Simplifying {name}. Iter: {i}"; SyntaxNode node = list[_rng.Next(list.Count)]; // Do not optimize checksum args and call itself. // We still want to remove these statements, however, so we focus on the expression only. InvocationExpressionSyntax invocParent = node.FirstAncestorOrSelf <InvocationExpressionSyntax>(); if (invocParent != null && IsChecksumCall(invocParent)) { continue; } // If we fail at creating a new bad example, then we want to be able to restore the state // so the reducer will not blow these up unnecessarily. int origVarCounter = _varCounter; simplifiedNodes.Clear(); SimplifyNode(node, !first, simplifiedNodes); foreach (SyntaxNode candidateNode in simplifiedNodes) { CompilationUnitSyntax candidate = Reduced.ReplaceNode(node, candidateNode); if (isInteresting(candidate)) { Reduced = candidate; return(true); } } _varCounter = origVarCounter; } return(false); } } List <SyntaxTrivia> outputComments = GetOutputComments(debug, release).Select(Comment).ToList(); SimplifyRuntime(); double oldSizeKiB = Original.NormalizeWhitespace().ToString().Length / 1024.0; double newSizeKiB = Reduced.NormalizeWhitespace().ToString().Length / 1024.0; SyntaxTriviaList newTrivia = originalTrivia.Add(Comment(FormattableString.Invariant($"// Reduced from {oldSizeKiB:F1} KiB to {newSizeKiB:F1} KiB"))) .AddRange(outputComments); Reduced = Reduced.WithLeadingTrivia(newTrivia); return(Reduced); }
public void ExecuteProgram_OutputsCorrectDiagnostics(int[] program, string expectedOutput) { programExecutor = new ProgramExecutor(mockWriter.Object); programExecutor.ExecuteProgram(program); mockWriter.Verify(mw => mw.Write(It.Is <string>((t => t.Equals(expectedOutput))))); }
public void ExecuteProgram_EqualsOpCodeWorksAsExpected(int[] program, int[] expectedOutput) { programExecutor = new ProgramExecutor(mockWriter.Object); Assert.Equal(expectedOutput, programExecutor.ExecuteProgram(program)); }
public void Update(string xml) { try { (CDFG cdfg, List<ParseException> exceptions) = XmlParser.Parse(xml); if (exceptions.Count == 0) { string js = String.Empty; bool optimizedCDFG = false; if (Settings.CreateGraph) { if (ProgramExecutor<string>.CanOptimizeCDFG(cdfg) && Settings.EnableOptimizations) { int boardWidth = Settings.BoardWidth; int boardHeight = Settings.BoardHeight; cancelSource?.Cancel(); cancelSource = new CancellationTokenSource(); CDFG newCdfg = new CDFG(); newCdfg.StartDFG = ProgramExecutor<string>.OptimizeCDFG<string>(boardWidth, boardHeight, cdfg, cancelSource.Token, Settings.EnableGC); newCdfg.AddNode(null, newCdfg.StartDFG); if (cancelSource.IsCancellationRequested) { return; } cdfg = newCdfg; optimizedCDFG = true; } (string nodes, string edges) = SimpleGraph.CDFGToSimpleGraph(cdfg); js = $"setGraph({nodes}, {edges});"; } js += $"ClearErrors();"; Browser.ExecuteScriptAsync(js); RunSimulator(cdfg, optimizedCDFG); } else { var errorInfos = exceptions.GroupBy(e => e.ID) .Select(e => $"{{id: \"{e.Key}\", message: \"{String.Join(@"\n", e.Select(ee => ee.Message))}\"}}"); string ids = string.Join(", ", errorInfos); string js = $"ShowBlocklyErrors([{ids}]);"; Browser.ExecuteScriptAsync(js); } } catch (ParseException e) { string message = $"ShowUnexpectedError(\"{e.Message.Replace('\"', ' ').Replace('\'', ' ')}\");"; Browser.ExecuteScriptAsync(message); Debug.WriteLine(e.Message + Environment.NewLine + e.StackTrace); } catch (Exception e) { string message = $"ShowUnexpectedError(\"{e.Message.Replace('\"', ' ').Replace('\'', ' ')}\");"; Browser.ExecuteScriptAsync(message); Debug.WriteLine(e.Message + Environment.NewLine + e.StackTrace); } }
private static void Main(string[] args) { ulong? seed = null; int? numPrograms = null; int? parallelism = null; FuzzlynOptions options = null; bool help = false; bool dumpOptions = false; bool? output = null; bool? executePrograms = null; bool? enableChecksumming = null; bool? reduce = null; string removeFixed = null; OptionSet optionSet = new OptionSet { { "seed=|s=", "Seed to use when generating a single program", (ulong v) => seed = v }, { "parallelism=", "Number of cores to use", (int?p) => parallelism = p }, { "num-programs=|n=", "Number of programs to generate", (int v) => numPrograms = v }, { "options=", "Path to options.json. Command-line options will override options from this file.", s => options = JsonConvert.DeserializeObject <FuzzlynOptions>(File.ReadAllText(s)) }, { "dump-options", "Dump options to stdout and do nothing else", v => dumpOptions = v != null }, { "output-source", "Output program source instead of feeding them directly to Roslyn and execution", v => output = v != null }, { "execute-programs", "Accept programs to execute on stdin and report back differences", v => executePrograms = v != null }, { "checksum", "Enable or disable checksumming in the generated code", v => enableChecksumming = v != null }, { "reduce", "Reduce program to a minimal example", v => reduce = v != null }, { "remove-fixed=", "Remove fixed programs in directory", v => removeFixed = v }, { "help|h", v => help = v != null } }; string error = null; try { List <string> leftover = optionSet.Parse(args); if (leftover.Any()) { error = "Unknown arguments: " + string.Join(" ", leftover); } } catch (OptionException ex) { error = ex.Message; } if (error != null) { Console.WriteLine("Fuzzlyn: {0}", error); Console.WriteLine("Use --help for help."); return; } if (help) { Console.WriteLine("Usage: fuzzlyn.exe"); optionSet.WriteOptionDescriptions(Console.Out); return; } if (executePrograms.HasValue && executePrograms.Value) { ProgramExecutor.Run(); return; } if (options == null) { options = new FuzzlynOptions(); } if (seed.HasValue) { options.Seed = seed.Value; } if (numPrograms.HasValue) { options.NumPrograms = numPrograms.Value; } if (parallelism.HasValue) { options.Parallelism = parallelism.Value; } if (output.HasValue) { options.Output = output.Value; } if (enableChecksumming.HasValue) { options.EnableChecksumming = enableChecksumming.Value; } if (reduce.HasValue) { options.Reduce = reduce.Value; } if (options.NumPrograms != 1 && options.Seed.HasValue) { Console.WriteLine("Error: Must specify exactly 1 program if a seed is specified."); return; } if (options.NumPrograms != 1 && options.Output) { Console.WriteLine("Error: Must specify exactly 1 program if output is desired."); return; } if (options.Reduce && !options.Seed.HasValue) { Console.WriteLine("Error: Cannot reduce without a seed."); return; } if (dumpOptions) { Console.Write(JsonConvert.SerializeObject(options, Formatting.Indented)); return; } if (removeFixed != null) { RemoveFixedPrograms(options, removeFixed); return; } if (options.Reduce) { ReduceProgram(options); } else { GenerateProgram(options); } }
static void Main(string[] args) { if (!Directory.Exists("unoptimizedPrograms")) { Directory.CreateDirectory("unoptimizedPrograms"); } List <perf_data> unoptimizedDatas = new List <perf_data>(); List <perf_data> optimizedDatas = new List <perf_data>(); List <perf_data> optimizedNoGCDatas = new List <perf_data>(); int nameID = 0; Random random = new Random(15231); TestTools tools = new TestTools(); for (int i = 0; i < 2000; i++) { try { perf_data unoptimizedData = new perf_data(); perf_data optimizedData = new perf_data(); perf_data optimizedNoGCData = new perf_data(); JSProgram program = new JSProgram(); program.Render = false; tools.ClearWorkspace(); program.CreateCDFG(3, 15, random); tools.ExecuteJS(program); string xml = tools.GetWorkspaceString(); var result = XmlParser.Parse(xml); if (result.Item2.Count > 0) { i--; continue; } int testCount = 5; float[] untimes = new float[testCount]; float[] optimes = new float[testCount]; Stopwatch watch = new Stopwatch(); for (int z = 0; z < testCount; z++) { watch.Reset(); watch.Start(); TestCommandExecutor commandExecutor = new TestCommandExecutor(); ProgramExecutor <string> programExecutor = new ProgramExecutor <string>(commandExecutor); programExecutor.TimeBetweenCommands = 0; programExecutor.EnableOptimizations = false; programExecutor.EnableGarbageCollection = false; programExecutor.Run(100, 100, result.Item1, false); unoptimizedData.makespan = commandExecutor.ticks; watch.Stop(); untimes[z] = watch.ElapsedMilliseconds / (float)testCount; } { int minSize = 10; while (true) { try { result.Item1.Nodes.ForEach(x => x.dfg.Nodes.ForEach(qq => qq.value.Reset())); TestCommandExecutor commandExecutor = new TestCommandExecutor(); ProgramExecutor <string> programExecutor = new ProgramExecutor <string>(commandExecutor); programExecutor.TimeBetweenCommands = 0; programExecutor.EnableOptimizations = false; programExecutor.EnableGarbageCollection = false; programExecutor.Run(minSize, minSize, result.Item1, false); break; } catch (Exception e) { if (minSize > 100) { Console.Write(e.Message + Environment.NewLine + e.StackTrace); } minSize++; } } unoptimizedData.size = minSize; } for (int z = 0; z < testCount; z++) { watch.Reset(); watch.Start(); TestCommandExecutor commandExecutor = new TestCommandExecutor(); ProgramExecutor <string> programExecutor = new ProgramExecutor <string>(commandExecutor); programExecutor.TimeBetweenCommands = 0; programExecutor.EnableOptimizations = true; programExecutor.EnableGarbageCollection = true; programExecutor.Run(100, 100, result.Item1, false); optimizedData.makespan = commandExecutor.ticks; watch.Stop(); optimes[z] = watch.ElapsedMilliseconds / (float)testCount; } { int minSize = 10; while (true) { try { result.Item1.Nodes.ForEach(x => x.dfg.Nodes.ForEach(qq => qq.value.Reset())); TestCommandExecutor commandExecutor = new TestCommandExecutor(); ProgramExecutor <string> programExecutor = new ProgramExecutor <string>(commandExecutor); programExecutor.TimeBetweenCommands = 0; programExecutor.EnableOptimizations = true; programExecutor.EnableGarbageCollection = true; programExecutor.Run(minSize, minSize, result.Item1, false); break; } catch (Exception) { minSize++; } } optimizedData.size = minSize; } { TestCommandExecutor commandExecutor = new TestCommandExecutor(); ProgramExecutor <string> programExecutor = new ProgramExecutor <string>(commandExecutor); programExecutor.TimeBetweenCommands = 0; programExecutor.EnableOptimizations = true; programExecutor.EnableGarbageCollection = false; programExecutor.Run(100, 100, result.Item1, false); optimizedNoGCData.makespan = commandExecutor.ticks; } { int minSize = 10; while (true) { try { result.Item1.Nodes.ForEach(x => x.dfg.Nodes.ForEach(qq => qq.value.Reset())); TestCommandExecutor commandExecutor = new TestCommandExecutor(); ProgramExecutor <string> programExecutor = new ProgramExecutor <string>(commandExecutor); programExecutor.TimeBetweenCommands = 0; programExecutor.EnableOptimizations = true; programExecutor.EnableGarbageCollection = false; programExecutor.Run(minSize, minSize, result.Item1, false); break; } catch (Exception) { minSize++; } } optimizedNoGCData.size = minSize; } unoptimizedData.time = untimes.Min(); optimizedData.time = optimes.Min(); unoptimizedDatas.Add(unoptimizedData); optimizedDatas.Add(optimizedData); optimizedNoGCDatas.Add(optimizedNoGCData); string path = Path.Combine("unoptimizedPrograms", $"program_{nameID++}.bc"); File.WriteAllText(path, xml); } catch (Exception e) { //Console.Write(e.Message + Environment.NewLine + e.StackTrace); i--; } Console.WriteLine(i); } tools.AssemblyCleanup(); File.WriteAllText("unoptimized_data.txt", String.Join(Environment.NewLine, unoptimizedDatas.Select(x => x.makespan + " " + x.time.ToString(CultureInfo.InvariantCulture) + " " + x.size))); File.WriteAllText("optimized_data.txt", String.Join(Environment.NewLine, optimizedDatas.Select(x => x.makespan + " " + x.time.ToString(CultureInfo.InvariantCulture) + " " + x.size))); File.WriteAllText("optimized_no_gc_data.txt", String.Join(Environment.NewLine, optimizedNoGCDatas.Select(x => x.makespan + " " + x.size))); }