public static void Main() { FConsole.Title = "SERVER APP"; GlobalExceptionHandler.Setup(); Jit.PreJit(); Core.Db = new JsonDb(); Core.Db.EnsureDbReady(); ReceiveQueue.OnPacket += PacketRouter.Route; ServerSocket.Start(Core.Settings.Port); FConsole.WriteLine("Online"); while (true) { var cmd = FConsole.ReadLine(); switch (cmd) { case "exit": Core.Db.Save(); Environment.Exit(0); break; default: break; } } }
public void GeneratesRightJitSettings(Jit jit, string expectedRuntimeNode) { const string customSettings = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<configuration>" + "<someConfig>withItsValue</someConfig>" + "</configuration>"; string customSettingsAndJit = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<configuration>" + "<someConfig>withItsValue</someConfig>" + expectedRuntimeNode + "</configuration>" + Environment.NewLine; using (var source = new StringReader(customSettings)) using (var destination = new Utf8StringWriter()) { AppConfigGenerator.Generate(new Job { Env = { Jit = jit } }.Freeze(), source, destination, Resolver); AssertAreEqualIgnoringWhitespacesAndCase(customSettingsAndJit, destination.ToString()); } }
private IConfig CreateConfig(Jit jit, Platform platform, Runtime runtime, IDiagnoser disassemblyDiagnoser) => ManualConfig.CreateEmpty() .With(Job.ShortRun.With(jit).With(platform).With(runtime)) .With(DefaultConfig.Instance.GetLoggers().ToArray()) .With(DefaultColumnProviders.Instance) .With(disassemblyDiagnoser) .With(new OutputLogger(Output));
private LogCapture Execute <T>(Jit jit, Platform platform, Runtime runtime) { var tailCallDiagnoser = new TailCallDiagnoser(false, true); CanExecute <T>(CreateConfig(jit, platform, runtime, tailCallDiagnoser)); return(tailCallDiagnoser.Logger); }
public override Object Execute(params Object[] args) { var kernel = Jit.Compile(TKernel); kernel.Initialize(Config, args); kernel.RunKernel(); return(kernel.FetchResult()); }
public EnvMode(string id, Jit jit, Platform platform) : this(id) { Jit = jit; Platform = platform; if (jit == Jit.LegacyJit) { Runtime = Runtime.Clr; } }
public PlatformConfig(Runtime runtime, Jit jit, Platform platform) { Add(new Job(Job.Dry, new EnvMode() { Runtime = runtime, Jit = jit, Platform = platform })); }
private void Verify(Runtime runtime, Jit jit, Platform platform, string expectedText) { var logger = new OutputLogger(Output); var config = new PlatformConfig(runtime, jit, platform).With(logger).With(DefaultColumnProviders.Instance); BenchmarkRunner.Run(new[] { BenchmarkConverter.TypeToBenchmarks(typeof(TestBenchmark), config) }); Assert.Contains(expectedText, logger.GetLog()); }
private IConfig CreateConfig(Jit jit, Platform platform, Runtime runtime, IDiagnoser disassemblyDiagnoser, RunStrategy runStrategy) => ManualConfig.CreateEmpty() .AddJob(Job.Dry.WithJit(jit) .WithPlatform(platform) .WithRuntime(runtime) .WithStrategy(runStrategy)) .AddLogger(DefaultConfig.Instance.GetLoggers().ToArray()) .AddColumnProvider(DefaultColumnProviders.Instance) .AddDiagnoser(disassemblyDiagnoser) .AddLogger(new OutputLogger(Output));
public void CanDisassembleInlinableBenchmarks(Jit jit, Platform platform, Runtime runtime) { var disassemblyDiagnoser = new DisassemblyDiagnoser( new DisassemblyDiagnoserConfig(printSource: true, maxDepth: 3)); CanExecute <WithInlineable>(CreateConfig(jit, platform, runtime, disassemblyDiagnoser, RunStrategy.Monitoring)); var disassemblyResult = disassemblyDiagnoser.Results.Values.Single(result => result.Methods.Count(method => method.Name.Contains(nameof(WithInlineable.JustReturn))) == 1); Assert.Contains(disassemblyResult.Methods, method => method.Maps.Any(map => map.SourceCodes.OfType <Asm>().All(asm => asm.Instruction.ToString().Contains("ret")))); }
public void CanDisassembleGenericTypes(Jit jit, Platform platform, Runtime runtime) { var disassemblyDiagnoser = (IDisassemblyDiagnoser)DisassemblyDiagnoser.Create( new DisassemblyDiagnoserConfig(printAsm: true, printIL: true, printSource: true, recursiveDepth: 3)); CanExecute <Generic <int> >(CreateConfig(jit, platform, runtime, disassemblyDiagnoser, RunStrategy.Monitoring)); var result = disassemblyDiagnoser.Results.Values.Single(); Assert.Contains(result.Methods, method => method.Maps.Any(map => map.Instructions.OfType <Asm>().Any())); }
private static void GenerateJitSettings(XmlDocument xmlDocument, XmlNode runtimeElement, Jit jit) { if (jit == Jit.Host) { return; } CreateNodeWithAttribute(xmlDocument, runtimeElement, "useLegacyJit", "enabled", jit == Jit.RyuJit || (jit == Jit.Host && HostEnvironmentInfo.GetCurrent().HasRyuJit) ? "0" : "1"); }
public static JobMutator CreateMutator(Jit jit, Platform platform) { var mutator = new JobMutator(jit.ToString() + platform). Add(Default.Jit.Mutate(jit)). Add(Default.Platform.Mutate(platform)); if (jit == Environments.Jit.LegacyJit) { mutator = mutator.Add(Default.Runtime.Mutate(Environments.Runtime.Clr)); } return(mutator); }
public void CanDisassembleAllMethodCalls(Jit jit, Platform platform, Runtime runtime) { var disassemblyDiagnoser = new DisassemblyDiagnoser( new DisassemblyDiagnoserConfig(printSource: true, maxDepth: 3)); CanExecute <WithCalls>(CreateConfig(jit, platform, runtime, disassemblyDiagnoser, RunStrategy.ColdStart)); AssertDisassembled(disassemblyDiagnoser, $"{nameof(WithCalls.Benchmark)}(Int32)"); AssertDisassembled(disassemblyDiagnoser, $"{nameof(WithCalls.Benchmark)}(Boolean)"); AssertDisassembled(disassemblyDiagnoser, $"{nameof(WithCalls.Static)}()"); AssertDisassembled(disassemblyDiagnoser, $"{nameof(WithCalls.Instance)}()"); AssertDisassembled(disassemblyDiagnoser, $"{nameof(WithCalls.Recursive)}()"); }
public async Task <IActionResult> CreateJitDatapoint([FromBody] Jit c) { Jit point = new Jit { method = c.method, timestamp = c.timestamp }; _MetricContext.Jit.Add(point); await _MetricContext.SaveChangesAsync(); return(CreatedAtAction("HTTP Data Created", new { date = point.timestamp }, null)); }
public AllocationsConfig() { var gcSettings = new GcMode() { Force = true, // tell BenchmarkDotNet to force GC collections after every iteration Server = true // we want to have the biggest Largest No GC Region possible }; Jit jit = Jit.RyuJit; // we want to run for x64 only, again to have the biggest Largest No GC Region possible Add(Job.Default .With(CsProjNet46Toolchain.Instance) .With(gcSettings.UnfreezeCopy()) .With(jit) .WithId(".NET 4.6")); // .NET Core 1.1 does not support GC.TryStartNoGCRegion method so we don't try it // .NET Core 2.0 fails when trying to call GC.TryStartNoGCRegion }
//http://localhost:8000/GrabCaster/Deploy?Configuration=Release&Platform=AnyCpu public string Deploy(string configuration, string platform) { try { string publishingFolder = Path.Combine(ConfigurationBag.DirectoryDeployment(), ConfigurationBag.DirectoryNamePublishing); var regTriggers = new Regex(ConfigurationBag.DeployExtensionLookFor); var deployFiles = Directory.GetFiles(publishingFolder, "*.*", SearchOption.AllDirectories) .Where( path => Path.GetExtension(path) == ".trigger" || Path.GetExtension(path) == ".event" || Path.GetExtension(path) == ".component"); StringBuilder results = new StringBuilder(); foreach (var file in deployFiles) { string projectName = Path.GetFileNameWithoutExtension(publishingFolder + file); string projectType = Path.GetExtension(publishingFolder + file).Replace(".", ""); bool resultOk = Jit.CompilePublishing(projectType, projectName, configuration, platform); if (resultOk) { string message = resultOk ? "without errors" : "with errors"; results.AppendLine( $"{projectName}.{projectType} builded {message} check the {projectName}Build.Log file for more information"); } } return(results.ToString()); } catch (Exception ex) { LogEngine.WriteLog( ConfigurationBag.EngineName, $"Error in {MethodBase.GetCurrentMethod().Name}", Constant.LogLevelError, Constant.TaskCategoriesError, ex, Constant.LogLevelError); return(ex.Message); } }
static void Main(string[] args) { string publishingFolder = Path.Combine(ConfigurationBag.DirectoryDeployment(), ConfigurationBag.DirectoryNamePublishing); var regTriggers = new Regex(ConfigurationBag.DeployExtensionLookFor); var deployFiles = Directory.GetFiles(publishingFolder, "*.*", SearchOption.AllDirectories) .Where( path => Path.GetExtension(path) == ".trigger" || Path.GetExtension(path) == ".event" || Path.GetExtension(path) == ".component"); foreach (var file in deployFiles) { string projectName = Path.GetFileNameWithoutExtension(publishingFolder + file); string projectType = Path.GetExtension(publishingFolder + file).Replace(".", ""); Jit.CompilePublishing(projectType, projectName, "Release", "AnyCpu"); } }
public void CanDisassembleAllMethodCalls(Jit jit, Platform platform, Runtime runtime) { var disassemblyDiagnoser = (IDisassemblyDiagnoser)DisassemblyDiagnoser.Create( new DisassemblyDiagnoserConfig(printAsm: true, printIL: true, printSource: true, recursiveDepth: 3)); CanExecute <WithCalls>(CreateConfig(jit, platform, runtime, disassemblyDiagnoser)); void AssertDisassembled(IDisassemblyDiagnoser diagnoser, string calledMethodName) { Assert.True(diagnoser.Results.Single().Value .Methods.Any(method => method.Name.Contains(calledMethodName) && method.Maps.Any(map => map.Instructions.Any())), $"{calledMethodName} is missing"); } AssertDisassembled(disassemblyDiagnoser, nameof(WithCalls.Benchmark)); AssertDisassembled(disassemblyDiagnoser, nameof(WithCalls.Static)); AssertDisassembled(disassemblyDiagnoser, nameof(WithCalls.Instance)); AssertDisassembled(disassemblyDiagnoser, nameof(WithCalls.Recursive)); AssertDisassembled(disassemblyDiagnoser, nameof(WithCalls.Virtual)); }
public static void Main() { FConsole.Title = "CLIENT APP"; GlobalExceptionHandler.Setup(); Jit.PreJit(); StartupScreen.Draw(); while (true) { DrawUI(); //HomeScreen.Draw(); var input = FConsole.ReadLine(); if (input.StartsWith('/')) { var command = input.Split(' ')[0]; switch (command) { case "/s": ServerCommandHandler.Process(input); break; case "/c": ChannelCommandHandler.Process(input); break; case "/dm": ServerCommandHandler.Process("/s 0"); break; } } else { Core.MyUser.SendMessage(input); } } }
public void GeneratesRightJitSettings(Jit jit, string expectedRuntimeNode) { string customSettings = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<configuration>" + "<someConfig>withItsValue</someConfig>" + "</configuration>"; string customSettingsAndJit = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<configuration>" + "<someConfig>withItsValue</someConfig>" + expectedRuntimeNode + "</configuration>" + Environment.NewLine; using (var source = new StringReader(customSettings)) using (var destination = new Utf8StringWriter()) { AppConfigGenerator.Generate(Job.Default.With(jit), source, destination); Assert.True(AreEqualIgnoringWhitespacesAndCase(customSettingsAndJit, destination.ToString())); } }
/// <summary> /// defines a new Dry Job that targets specified Framework, JIT and Platform /// </summary> /// <param name="targetFrameworkMoniker">Target Framework to test.</param> public DryJobAttribute(TargetFrameworkMoniker targetFrameworkMoniker, Jit jit, Platform platform) : base(GetJob(targetFrameworkMoniker, jit, platform)) { }
public void CheckCore(Runtime runtime, Jit jit, Platform platform, string exptectedText) { Verify(runtime, jit, platform, exptectedText); }
public static string ToConfig(this Jit jit) { return(jit == Jit.LegacyJit ? "1" : "0"); }
public static string ToConfig(this Jit jit) => jit == Jit.LegacyJit ? "1" : "0";
public static IJob With(this IJob job, Jit jit) => job.With(j => j.Jit = jit);
public void CheckCore(Jit jit, Platform platform, string expectedText) { Verify(CoreRuntime.Core21, jit, platform, expectedText); }
public void CheckClrOnWindows(Jit jit, Platform platform, string expectedText) { Verify(ClrRuntime.Net461, jit, platform, expectedText); }
// Env public static Job With(this Job job, Jit jit) => job.WithCore(j => j.Env.Jit = jit);
/// <summary> /// defines a new LongRun Job that targets specified Framework, JIT and Platform /// </summary> /// <param name="runtimeMoniker">Target Framework to test.</param> /// <param name="jit">Jit to test.</param> /// <param name="platform">Platform to test.</param> public LongRunJobAttribute(RuntimeMoniker runtimeMoniker, Jit jit, Platform platform) : base(GetJob(Job.LongRun, runtimeMoniker, jit, platform)) { }
public BenchmarksConfig() { //Add(new Job1(), new Job2()); //Add(new Column1(), new Column2()); //Add(new Exporter1(), new Exporter2()); //Add(new Logger1(), new Logger2()); //Add(new Diagnoser1(), new Diagnoser2()); //Add(new Analyser1(), new Analyser2()); //Add(new Filter1(), new Filter2()); Job[] jobs = new Job[] { Job.Default.With(ClrRuntime.Net48), Job.Default.With(CoreRuntime.Core30), //Job.CoreRT, //Job.Mono, }; Runtime[] runtimes = new Runtime[] { ClrRuntime.Net48, CoreRuntime.Core30, //Runtime.CoreRT, //Runtime.Mono, //new MonoRuntime("Mono x64", @"C:\Program Files\Mono\bin\mono.exe"), }; Platform[] platforms = new Platform[] { Platform.AnyCpu, Platform.X64, Platform.X86, }; Jit[] jits = new Jit[] { Jit.Default, //Jit.LegacyJit, //Jit.Llvm, //Jit.RyuJit, }; foreach (var platform in platforms) { foreach (var runtime in runtimes) { foreach (var jit in jits) { foreach (var job in jobs) { Add( job .With(platform) .With(jit) .With(runtime) .WithLaunchCount(1) .WithMinIterationCount(100) .WithIterationCount(100) .WithMaxIterationCount(110) .WithIterationTime(TimeInterval.Millisecond * 50) .WithMaxRelativeError(0.01) .WithId(platform + "-" + runtime + "-" + jit + "-" + job.Id)); } } } } }
public static Job With(this Job job, Jit jit) => job.With(job.Env.Jit.Mutate(jit));