示例#1
0
        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;
                }
            }
        }
示例#2
0
        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());
                }
        }
示例#3
0
 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);
        }
示例#5
0
        public override Object Execute(params Object[] args)
        {
            var kernel = Jit.Compile(TKernel);

            kernel.Initialize(Config, args);
            kernel.RunKernel();
            return(kernel.FetchResult());
        }
示例#6
0
 public EnvMode(string id, Jit jit, Platform platform) : this(id)
 {
     Jit      = jit;
     Platform = platform;
     if (jit == Jit.LegacyJit)
     {
         Runtime = Runtime.Clr;
     }
 }
示例#7
0
 public PlatformConfig(Runtime runtime, Jit jit, Platform platform)
 {
     Add(new Job(Job.Dry, new EnvMode()
     {
         Runtime  = runtime,
         Jit      = jit,
         Platform = platform
     }));
 }
示例#8
0
        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());
        }
示例#9
0
 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));
示例#10
0
        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");
        }
示例#13
0
        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);
        }
示例#14
0
        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);
            }
        }
示例#18
0
        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");
            }
        }
示例#19
0
        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));
        }
示例#20
0
        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()));
            }
        }
示例#22
0
 /// <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))
 {
 }
示例#23
0
 public void CheckCore(Runtime runtime, Jit jit, Platform platform, string exptectedText)
 {
     Verify(runtime, jit, platform, exptectedText);
 }
示例#24
0
 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";
示例#26
0
 public static IJob With(this IJob job, Jit jit) => job.With(j => j.Jit = jit);
示例#27
0
 public void CheckCore(Jit jit, Platform platform, string expectedText)
 {
     Verify(CoreRuntime.Core21, jit, platform, expectedText);
 }
示例#28
0
 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);
示例#30
0
 /// <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))
 {
 }
 // Env
 public static Job With(this Job job, Jit jit) => job.WithCore(j => j.Env.Jit                          = jit);
示例#32
0
 public static IJob With(this IJob job, Jit jit) => job.With(j => j.Jit = jit);
示例#33
0
        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));
                        }
                    }
                }
            }
        }
示例#34
0
 public static Job With(this Job job, Jit jit) => job.With(job.Env.Jit.Mutate(jit));