static void Main(string[] args) { if (args.Length < 1 || !uint.TryParse(args[0], out var numNodes)) { numNodes = 4; } Console.WriteLine("Building Application..."); var compiler = new ApplicationCompiler(); compiler.AddService <BankTestsService>(); var compiled = compiler.Compile(numNodes); Console.WriteLine("Building Host..."); var deploymentTimestamp = DateTime.UtcNow; var emulator = new EmulatorHost.Emulator($"bank/emulator/{deploymentTimestamp:o}", deploymentTimestamp); Console.WriteLine("Starting Host..."); emulator.Run(compiled); Console.WriteLine("Done (hit enter to terminate)..."); Console.ReadLine(); emulator.Shutdown(); }
static void Main(string[] args) { Console.WriteLine("Building Application..."); var compiler = new ApplicationCompiler(); uint numberProcesses = 5; uint workersPerProcess = 2; compiler .AddService <MinerService>() .AddBuildStep(serviceBuilder => serviceBuilder.OnFirstStart( new SearchJob() { Target = 100007394059441.GetHashCode(), Start = 100000000000000, Count = 10000000000, NumberWorkers = numberProcesses * workersPerProcess })) ; var application = compiler.Compile(numberProcesses); Console.WriteLine("Building Host..."); var deploymentTimestamp = DateTime.UtcNow; var emulator = new EmulatorHost.Emulator($"miner/emulator/{deploymentTimestamp:o}", deploymentTimestamp); Console.WriteLine("Starting Host..."); emulator.Run(application); Console.WriteLine("Done (hit enter to terminate)..."); Console.ReadLine(); emulator.Shutdown(); }
/// <summary> /// Compiles in a seperate appdomain utilitizing one of the compilers on the stack. /// </summary> public static void Compile(ErrorSink /*!*/ errorSink, CompilationParameters /*!*/ ps) { // obtain a compiler StackItem item = new StackItem(); lock (stack) { if (stack.Count > 0) { item = stack.Pop(); } } if (item.Compiler == null) { item.Compiler = ApplicationCompiler.CreateRemoteCompiler(); } // compile item.Compiler.RemoteCompile(ref errorSink, ps); // check whether the separate appdomain is not too weedy if (++item.CompileCounter == 1 || item.CompileCounter == compileCounterTreshold) { item.CompileCounter = 1; CallBackDisplay display = new CallBackDisplay(); // avoid passing the array of assemblies across appdomain boundary item.Compiler.Domain.DoCallBack(display.Handler); if (item.RemoteAssemblyCount == 0) { item.RemoteAssemblyCount = display.AssemblyCount; } else { if (display.AssemblyCount > (2 * item.RemoteAssemblyCount)) { AppDomain.Unload(item.Compiler.Domain); return; } } } // recycle the compiler lock (stack) stack.Push(item); }
static void Main(string[] args) { var applicationConfiguration = new RideSharing.Benchmark.Configuration() { NumberGeneratorProcesses = 1, NumberRiders = 10, NumberDrivers = 10, NumberServiceProcesses = 1, Duration = TimeSpan.FromSeconds(10), Cooldown = TimeSpan.FromSeconds(5), Rate = 0.333333333333, }; var hostConfiguration = new EmulatorHost.Configuration() { RoundTripMessages = true, RoundTripProcessStateEvery = int.MaxValue, DeliverStaleExternalsOneOutOf = 10000 }; Console.WriteLine("Building Application..."); var application = new ApplicationCompiler() .SetConfiguration(applicationConfiguration) .AddService <RideSharingBenchmark>() .Compile(applicationConfiguration.NumberServiceProcesses + applicationConfiguration.NumberGeneratorProcesses); var experimentAndHost = "ridesharing/emulator/"; var localOrCloudDeployment = Environment.GetEnvironmentVariable("REACTIVE_MACHINE_DIR") == null ? "cloud" : "local"; var deploymentTimestamp = DateTime.UtcNow; var deploymentId = string.Format("{1}{2}/{0:o}", deploymentTimestamp, experimentAndHost, localOrCloudDeployment); var emulator = new EmulatorHost.Emulator(deploymentId, deploymentTimestamp); Console.WriteLine("Starting Host..."); emulator.Run(application); Console.WriteLine("Done (hit enter to terminate)..."); Console.ReadLine(); emulator.Shutdown(); }
static void Main(string[] args) { if (args.Length < 1 || !uint.TryParse(args[0], out var numNodes)) { numNodes = 4; } var configuration = new EmulatorHost.Configuration() { MultiThreaded = true, ApplicationLogLevel = LogLevel.Trace, RuntimeLogLevel = LogLevel.Trace, FileLogLevel = LogLevel.Trace, LocalLogDirectory = "C:\\logs\\", }; var loggingConfig = new ReactiveMachine.LoggingConfiguration() { //SendLogLevel = LogLevel.Trace, //LockLogLevel = LogLevel.Trace }; Console.WriteLine("Building Application..."); var compiler = new ApplicationCompiler(); compiler.AddService <BankTestsService>(); compiler.AddBuildStep(sb => sb .SetConfiguration(configuration) .SetConfiguration(loggingConfig)); var compiled = compiler.Compile(numNodes); Console.WriteLine("Building Host..."); var deploymentTimestamp = DateTime.UtcNow; var emulator = new EmulatorHost.Emulator($"bank/emulator/{deploymentTimestamp:o}", deploymentTimestamp); Console.WriteLine("Starting Host..."); emulator.Run(compiled); Console.WriteLine("Done (hit enter to terminate)..."); Console.ReadLine(); emulator.Shutdown(); }
static void Main(string[] args) { Console.WriteLine("Building Application..."); var compiler = new ApplicationCompiler(); compiler.AddService <PingPongService>(); var application = compiler.Compile(2); Console.WriteLine("Starting Host..."); var deploymentTimestamp = DateTime.UtcNow; var emulator = new EmulatorHost.Emulator($"pingpong/emulator/{deploymentTimestamp:o}", deploymentTimestamp); emulator.Run(application); Console.WriteLine("Done (hit enter to terminate)..."); Console.ReadLine(); emulator.Shutdown(); }
static void Main(string[] args) { var compiler = new ApplicationCompiler(); Console.WriteLine("Setting configuration objects..."); compiler.SetConfiguration(new HelloWorldTestConfiguration() { NumberRepetitions = 100 }); compiler.SetConfiguration(new ReactiveMachine.TelemetryBlobWriter.Configuration() { CollectHostEvents = true, CollectApplicationEvents = true, CollectThroughput = false, }); Console.WriteLine("Building Application..."); compiler.AddService <HelloWorldTestService>(); Console.WriteLine("Compiling Application..."); var compiledApplication = compiler.Compile(numberProcesses: 1); Console.WriteLine("Building Host..."); var deploymentTimestamp = DateTime.UtcNow; var deploymentId = $"helloworld/emulator/{deploymentTimestamp:o}"; var emulator = new EmulatorHost.Emulator(deploymentId, deploymentTimestamp); Console.WriteLine("Starting Host..."); emulator.Run(compiledApplication); Console.WriteLine("Done (hit enter to terminate)..."); Console.ReadLine(); emulator.Shutdown(); }
static void Main(string[] args) { var configuration = new EmulatorHost.Configuration() { MultiThreaded = false, RoundTripMessages = true, RoundTripProcessStateEvery = int.MaxValue, DeliverStaleExternalsOneOutOf = 1, ApplicationLogLevel = LogLevel.Trace, RuntimeLogLevel = Debugger.IsAttached ? LogLevel.Trace : LogLevel.Warning, ConsoleLogLevel = LogLevel.Trace, FileLogLevel = LogLevel.Trace, }; var loggingConfig = new ReactiveMachine.LoggingConfiguration() { SendLogLevel = LogLevel.Trace, LockLogLevel = LogLevel.Trace, ProgressLogLevel = LogLevel.None, }; Console.WriteLine("Building Application..."); var application = new ApplicationCompiler() .AddService <TestsService>() .SetConfiguration <EmulatorHost.Configuration>(configuration) .SetConfiguration <ReactiveMachine.LoggingConfiguration>(loggingConfig) .Compile(5); Console.WriteLine("Building Host..."); var deploymentTimestamp = DateTime.UtcNow; var emulator = new EmulatorHost.Emulator($"localtests/{deploymentTimestamp:o}", deploymentTimestamp); Console.WriteLine($"Starting Test {deploymentTimestamp}..."); emulator.Run(application); Console.WriteLine("Done (hit enter to terminate)..."); Console.ReadLine(); emulator.Shutdown(); }
public void RemoteCompile(ref ErrorSink /*!*/ errorSink, CompilationParameters /*!*/ ps) { lock (buildMutex) // TODO: do we need thread-safety (if yes, there is a better way)? { //if (++buildCounter % 10 == 0) // TODO: is it possible to estimate size of memory allocated by the domain? //{ // // if a referenced assembly gets updated then we should reload the domain as well // AppDomain.Unload(remoteCompiler.Domain); // remoteCompiler = null; //} if (remoteCompiler != null) { AppDomain.Unload(remoteCompiler.Domain); } remoteCompiler = ApplicationCompiler.CreateRemoteCompiler(); remoteCompiler.RemoteCompile(ref errorSink, ps); } }
protected override void EndProcessing() { Action <string, object> writeVerbose = (targetType, target) => WriteVerbose($"Exporting {CachedObjects.Objects.Count()} object(s) to {targetType} {target}"); switch (ParameterSetName) { case "ToPath": var path = GetUnresolvedProviderPathFromPSPath(Path); writeVerbose("path", path); this.WriteObjectIf(!PassThru, Directory ? CachedObjects.WriteToFolder(path) : CachedObjects.WriteToFile(path).AsEnumerable()); this.WriteObjectIf(PassThru, CachedObjects); break; case "ToTextWriter": writeVerbose("TextWriter", ""); CachedObjects.WriteToTextWriter(TextWriter ?? Console.Out); this.WriteObjectIf(PassThru, CachedObjects); break; case "ToStream": writeVerbose("Stream", ""); CachedObjects.WriteToStream(Stream); this.WriteObjectIf(PassThru, CachedObjects); break; case "ToDatabase": writeVerbose("database", Database); ApplicationImporter.Import(CachedObjects, DevClientPath ?? DefaultDevClientPath, ServerName, Database, ImportAction); if (AutoCompile) { ApplicationCompiler.Compile(CachedObjects, DevClientPath ?? DefaultDevClientPath, ServerName, Database); } this.WriteObjectIf(PassThru, CachedObjects); break; } }
/// <summary> /// Runs the compiler with specified options. /// </summary> /// <param name="args">Command line arguments.</param> /// <returns>Whether the compilation was successful.</returns> public bool Compile(List <string> /*!*/ args) { if (args == null) { throw new ArgumentNullException("args"); } TextErrorSink errorSink = null; // processes arguments: try { try { commandLineParser.Parse(args); } finally { if (commandLineParser.Quiet) { output = errors = TextWriter.Null; } else if (commandLineParser.RedirectErrors) { output = errors = Console.Out; } else { output = Console.Out; errors = Console.Error; } errorSink = new TextErrorSink(errors); ShowLogo(); if (commandLineParser.ShowHelp) { ShowHelp(); } else { DumpArguments(args); } } } catch (InvalidCommandLineArgumentException e) { e.Report(errorSink); return(false); } if (commandLineParser.ShowHelp) { return(true); } // allow loading of all assemblies in /Bin directory by their FullName HandleAssemblies(Path.Combine(commandLineParser.Parameters.SourceRoot, "Bin")); // ApplicationContext.DefineDefaultContext(false, true, false); ApplicationContext app_context = ApplicationContext.Default; CompilerConfiguration compiler_config; // loads entire configuration: try { if (commandLineParser.Parameters.ConfigPaths.Count == 0) { // Add config files for known targets switch (commandLineParser.Parameters.Target) { case ApplicationCompiler.Targets.Web: if (File.Exists("web.config")) { commandLineParser.Parameters.ConfigPaths.Add(new FullPath("web.config")); } break; case ApplicationCompiler.Targets.WinApp: if (File.Exists("app.config")) { commandLineParser.Parameters.ConfigPaths.Add(new FullPath("app.config")); } break; } } compiler_config = ApplicationCompiler.LoadConfiguration(app_context, commandLineParser.Parameters.ConfigPaths, output); commandLineParser.Parameters.ApplyToConfiguration(compiler_config); } catch (ConfigurationErrorsException e) { if (commandLineParser.Verbose) { output.WriteLine(CoreResources.GetString("reading_configuration") + ":"); output.WriteLine(); if (!String.IsNullOrEmpty(e.Filename)) // Mono puts here null { output.WriteLine(FileSystemUtils.ReadFileLine(e.Filename, e.Line).Trim()); output.WriteLine(); } } errorSink.AddConfigurationError(e); return(false); } // load referenced assemblies: try { try { app_context.AssemblyLoader.Load(commandLineParser.Parameters.References); } finally { if (commandLineParser.Verbose) { DumpLoadedLibraries(); } } } catch (ConfigurationErrorsException e) { errorSink.AddConfigurationError(e); return(false); } output.WriteLine(CoreResources.GetString("performing_compilation") + " ..."); try { CommandLineParser p = commandLineParser; Statistics.DrawGraph = p.DrawInclusionGraph; errorSink.DisabledGroups = compiler_config.Compiler.DisabledWarnings; errorSink.DisabledWarnings = compiler_config.Compiler.DisabledWarningNumbers; errorSink.TreatWarningsAsErrors = compiler_config.Compiler.TreatWarningsAsErrors; // initializes log: DebugUtils.ConsoleInitialize(Path.GetDirectoryName(p.Parameters.OutPath)); new ApplicationCompiler().Compile(app_context, compiler_config, errorSink, p.Parameters); } catch (InvalidSourceException e) { e.Report(errorSink); return(false); } catch (Exception e) { errorSink.AddInternalError(e); return(false); } var errorscount = errorSink.ErrorCount + errorSink.FatalErrorCount; var warningcount = errorSink.WarningCount + errorSink.WarningAsErrorCount; output.WriteLine(); output.WriteLine("Build complete -- {0} error{1}, {2} warning{3}.", errorscount, (errorscount == 1) ? "" : "s", warningcount, (warningcount == 1) ? "" : "s"); return(!errorSink.AnyError); }
static void Main(string[] args) { Console.WriteLine("Building Application..."); var appConfig = new CounterBenchmarkConfiguration() { NumberGeneratorProcesses = 4, NumberGenerators = 4, NumberCounterProcesses = 4, NumberCounters = 4, Duration = TimeSpan.FromSeconds(10), Cooldown = TimeSpan.FromSeconds(5), Rate = 4, Implementation = CounterImplementation.UpdateBased, }; //var appConfig = new CounterBenchmarkConfiguration() //{ // NumberGeneratorProcesses = 2, // NumberGenerators = 1000, // NumberCounterProcesses = 2, // NumberCounters = 1000, // NumberRequests = 5000, // Stagger = TimeSpan.FromSeconds(1), // Implementation = CounterImplementation.UpdateBased, //}; //var appConfig = new CounterBenchmarkConfiguration() //{ // NumberGeneratorProcesses = 1, // NumberGenerators = 10000, // NumberCounterProcesses = 1, // NumberCounters = 1, // NumberRequests = 200000, // Stagger = TimeSpan.FromSeconds(1), // Implementation = CounterImplementation.UpdateBased, //}; var hostConfig = new EmulatorHost.Configuration() { MultiThreaded = true, RoundTripMessages = true, RoundTripProcessStateEvery = int.MaxValue, DeliverStaleExternalsOneOutOf = 1, ConsoleLogLevel = LogLevel.Information, FileLogLevel = Debugger.IsAttached ? LogLevel.Trace : LogLevel.None, LocalLogDirectory = "C:\\logs\\", ApplicationLogLevel = LogLevel.Trace, // log through runtime HostLogLevel = LogLevel.Trace, RuntimeLogLevel = LogLevel.Trace }; var telemetryConfig = new ReactiveMachine.TelemetryBlobWriter.Configuration() { CollectHostEvents = false, CollectApplicationEvents = (System.Diagnostics.Debugger.IsAttached || appConfig.IsFixedRateExperiment), CollectThroughput = (System.Diagnostics.Debugger.IsAttached || appConfig.IsLoadLoopsExperiment), }; var application = new ApplicationCompiler() .SetConfiguration(appConfig) .SetConfiguration(telemetryConfig) .SetConfiguration(hostConfig) .AddService <CounterBenchmarkService>() .Compile(appConfig.NumberCounterProcesses + appConfig.NumberGeneratorProcesses); var experimentAndHost = "counter/emulator/"; var localOrCloudDeployment = Environment.GetEnvironmentVariable("REACTIVE_MACHINE_DIR") == null ? "cloud" : "local"; var deploymentTimestamp = DateTime.UtcNow; var deploymentId = string.Format("{1}{2}/{0:o}", deploymentTimestamp, experimentAndHost, localOrCloudDeployment); var emulator = new EmulatorHost.Emulator(deploymentId, deploymentTimestamp); Console.WriteLine("Starting Host..."); emulator.Run(application); Console.WriteLine("Done (hit enter to terminate)..."); Console.ReadLine(); emulator.Shutdown(); }
/// <exlude/> protected override void ProcessRecord() { ApplicationCompiler.Compile(Application, DevClientPath ?? DefaultDevClientPath, ServerName, Database); }
public override bool Execute() { Log.LogMessage(MessageImportance.Normal, "Phalanger Compilation Task"); CompilationParameters ps = new CompilationParameters(); // source root (project directory by default): ps.SourceRoot = new FullPath(sourceRoot); // target type: string assembly_extension; switch (outputType.ToLowerInvariant()) { case "dll": case "library": ps.Target = ApplicationCompiler.Targets.Dll; assembly_extension = ".dll"; break; case "exe": case "console": ps.Target = ApplicationCompiler.Targets.Console; assembly_extension = ".exe"; break; case "winexe": case "winapp": ps.Target = ApplicationCompiler.Targets.WinApp; assembly_extension = ".exe"; break; case "webapp": ps.Target = ApplicationCompiler.Targets.Web; assembly_extension = ".dll"; // TODO: precompile option return(true); default: Log.LogError("Invalid output type: '{0}'.", outputType); return(false); } if (Path.GetExtension(outputAssembly) != assembly_extension) { Log.LogError("Output assembly extension doesn't match project type."); return(false); } if (contentFiles != null) { foreach (string file in contentFiles) { if (String.Compare(Path.GetExtension(file), ".config", true) == 0) { ps.ConfigPaths.Add(new FullPath(file, ps.SourceRoot)); } } } // debug symbols: ps.Debuggable = this.Debug; // compilation of executables in debug mode from VisualStudio/MSBuild will produce 32bit assembly to EE working properly ps.Force32Bit = this.Debug && assembly_extension.EqualsOrdinalIgnoreCase(".exe"); // language features: ps.Pure = ApplicationCompiler.IsPureUnit(compilationMode); if (!String.IsNullOrEmpty(languageFeatures)) { try { ps.LanguageFeatures = (Core.LanguageFeatures)Enum.Parse(typeof(Core.LanguageFeatures), languageFeatures, true); } catch (Exception) { Log.LogError("Invalid language features."); return(false); } } else { ps.LanguageFeatures = (ps.Pure) ? Core.LanguageFeatures.PureModeDefault : Core.LanguageFeatures.Default; } // source paths: GetSourcePaths(ps.SourceRoot, ps.SourcePaths); // directories (TODO) // ps.SourceDirs // extensions (TODO) // ps.FileExtensions = null; if (ps.SourcePaths.Count == 0 && ps.SourceDirs.Count == 0) { Log.LogError("No source files to compile."); return(false); } // out path: try { Directory.CreateDirectory(Path.GetDirectoryName(outputAssembly)); } catch (Exception e) { Log.LogErrorFromException(e); return(false); } ps.OutPath = new FullPath(outputAssembly); // doc path (TODO): ps.DocPath = FullPath.Empty; // startup file/class: ps.StartupFile = FullPath.Empty; // TODO: string startup_class = null; if (ps.Target == ApplicationCompiler.Targets.Console || ps.Target == ApplicationCompiler.Targets.WinApp) { if (ps.Pure) { if (!String.IsNullOrEmpty(startupObject)) { // TODO: startup_class = startupObject; Log.LogWarning("Startup class is ignored -- the feature is not supported yet."); return(false); } else { // TODO: startup_class = null; } } else { if (String.IsNullOrEmpty(startupObject)) { if (ps.SourcePaths.Count > 1) { Log.LogError("The startup file must be specified in the project property pages."); return(false); } else { ps.StartupFile = new FullPath(ps.SourcePaths[0], ps.SourceRoot); } } else { try { ps.StartupFile = new FullPath(startupObject, ps.SourceRoot); } catch (Exception e) { Log.LogErrorFromException(e); return(false); } // startup file is not in the list of compiled files: if (ps.SourcePaths.IndexOf(ps.StartupFile) == -1) { Log.LogError("The startup file specified in the property pages must be included in the project."); return(false); } } } } // icon: ps.Icon = null; try { if (applicationIcon != null) { ps.Icon = new Win32IconResource(new FullPath(applicationIcon, ps.SourceRoot)); } } catch (Exception e) { Log.LogErrorFromException(e); return(false); } // strong name, version (TODO): try { ps.Version = new Version(1, 0, 0, 0); ps.Key = null; if (!string.IsNullOrEmpty(keyFile)) { using (FileStream file = new FileStream(new FullPath(keyFile, ps.SourceRoot), FileMode.Open, FileAccess.Read)) ps.Key = new StrongNameKeyPair(file); } } catch (Exception e) { Log.LogErrorFromException(e); return(false); } //Resources foreach (ITaskItem resource in this.ResourceFiles) { bool publicVisibility = true; string access = resource.GetMetadata("Access"); if (String.CompareOrdinal("Private", access) == 0) { publicVisibility = false; } string filename = resource.ItemSpec; string logicalName = resource.GetMetadata("LogicalName"); if (String.IsNullOrEmpty(logicalName)) { logicalName = Path.GetFileName(resource.ItemSpec); } ps.Resources.Add(new ResourceFileReference(filename, logicalName, publicVisibility)); } // referenced assemblies: //if (referencedAssemblies != null) if (references != null) { foreach (ITaskItem assemblyReference in references /*referencedAssemblies*/) { // script library root: var scriptLibraryRoot = assemblyReference.GetMetadata("MSARoot"); if (scriptLibraryRoot != null) { scriptLibraryRoot = scriptLibraryRoot.Trim(); } if (string.IsNullOrEmpty(scriptLibraryRoot)) { scriptLibraryRoot = null; } // add the reference to CompilationParameters: ps.References.Add(new CompilationParameters.ReferenceItem() { Reference = assemblyReference.ItemSpec, LibraryRoot = scriptLibraryRoot }); } } // errors, warnings: ErrorSink sink = new CompilerErrorSink(this.Log); if (!String.IsNullOrEmpty(disabledWarnings)) { try { ps.DisableWarningNumbers = ConfigUtils.ParseIntegerList(disabledWarnings, ',', 1, 10000, null); } catch (Exception) { Log.LogError("Invalid list of disabled warnings."); return(false); } } else { ps.DisableWarningNumbers = ArrayUtils.EmptyIntegers; } ps.EnableWarnings |= WarningGroups.DeferredToRuntime; // enable deferred to runtime warnings ps.TreatWarningsAsErrors = this.TreatWarningsAsErrors; // compile try { //ApplicationCompiler.CompileInSeparateDomain(sink, ps); RemoteCompile(ref sink, ps); } catch (InvalidSourceException e) { e.Report(sink); return(false); } catch (Exception e) { sink.AddInternalError(e); return(false); } return(!sink.AnyError); }