/// <summary> /// Executes the worker. /// </summary> /// <param name="args"> /// Arguments like the master's hostname. /// See <see cref="WorkerArgumentParser" /> for more information. /// </param> public static void Run(string[] args) { ProcessUtils.SetDefaultCultureInfo(CultureInfo.InvariantCulture); LoggingHelper.Configure($"consoleOutput_Worker_{ProcessUtils.GetCurrentProcessId()}.log"); Randomizer.Configure(); // Parse arguments. var argsParser = new WorkerArgumentParser(); if (!ArgumentParserUtils.ParseArguments(argsParser, args)) { return; } LoggingHelper.ChangeConsoleLoggingLevel(argsParser.VerbosityLevel); // Create an actor system for remote nodes to deploy onto. var akkaConfig = CustomizeAkkaConfiguration( argsParser.OwnHostName, argsParser.SeedHostName, argsParser.Port, argsParser.VerbosityLevel >= VerbosityLevel.Trace); var actorSystem = ActorSystem.Create(AkkaNames.ActorSystemName, akkaConfig); // Create an actor checking whether the cluster seed is still up. actorSystem.ActorOf(Props.Create(() => new SeedObserver())); // Do not stop execution before the actor system has been terminated. var cluster = Cluster.Get(actorSystem); actorSystem.WhenTerminated.Wait(); cluster.Leave(cluster.SelfAddress); }
protected void Application_Start() { GlobalConfiguration.Configure(WebApiConfig.Register); AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); LoggingHelper.Configure(typeof(MvcApplication)); ConfigureUnhandledExceptionsHandler(); }
/// <summary> /// Entry point to the program. /// </summary> /// <param name="args">If 'master' is included as argument, a /// <see cref="Master{TTargetAlgorithm,TInstance,TResult}"/> is starting using the remaining arguments. /// Otherwise, a <see cref="Worker"/> is started with the provided arguments.</param> public static void Main(string[] args) { ProcessUtils.SetDefaultCultureInfo(CultureInfo.InvariantCulture); LoggingHelper.Configure($"parserLog_{ProcessUtils.GetCurrentProcessId()}.log"); // Parse arguments. var argsParser = new SapsRunnerConfigurationParser(); if (!ArgumentParserUtils.ParseArguments(argsParser, args)) { return; } var config = argsParser.ConfigurationBuilder.Build(); // Start master or worker depending on arguments. if (argsParser.IsMaster) { Dictionary <string, IAllele> bestParameters; switch (config.GenericParameterization) { case GenericParameterization.RandomForestAverageRank: bestParameters = GenericSapsEntryPoint < GenomePredictionRandomForest <AverageRankStrategy>, GenomePredictionForestModel <GenomePredictionTree>, AverageRankStrategy> .Run(argsParser.AdditionalArguments, config); break; case GenericParameterization.RandomForestReuseOldTrees: bestParameters = GenericSapsEntryPoint < GenomePredictionRandomForest <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(argsParser.AdditionalArguments, config); break; case GenericParameterization.StandardRandomForest: case GenericParameterization.Default: default: bestParameters = GenericSapsEntryPoint < StandardRandomForestLearner <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(argsParser.AdditionalArguments, config); break; } Program.LogBestParameters(bestParameters, config); } else { Worker.Run(args); } }
/// <summary> /// Runs the master. /// </summary> /// <param name="args"> /// Arguments to configure the run, e.g. population size or port to use. /// </param> /// <param name="algorithmTunerBuilder"> /// A function creating a <see cref="AlgorithmTuner{TTargetAlgorithm, TInstance, TResult, TLearnerModel, TPredictorModel, TSamplingStrategy}"/> instance. /// </param> /// <returns> /// The <see cref="Dictionary{String, IAllele}"/>, containing the best configuration. /// </returns> public static Dictionary <string, IAllele> Run( string[] args, Func <AlgorithmTunerConfiguration, string, string, AlgorithmTuner <TTargetAlgorithm, TInstance, TResult, TLearnerModel, TPredictorModel, TSamplingStrategy> > algorithmTunerBuilder) { ProcessUtils.SetDefaultCultureInfo(CultureInfo.InvariantCulture); LoggingHelper.Configure($"consoleOutput_Master_{ProcessUtils.GetCurrentProcessId()}.log"); Randomizer.Configure(); var argsParser = new MasterArgumentParser(); if (!ArgumentParserUtils.ParseArguments(argsParser, args)) { return(null); } var configuration = CreateAlgorithmTunerConfiguration(argsParser); LoggingHelper.ChangeConsoleLoggingLevel(configuration.Verbosity); LoggingHelper.WriteLine(VerbosityLevel.Info, $"Configuration:{Environment.NewLine}{configuration}"); // Create status file directories. Directory.CreateDirectory(configuration.StatusFileDirectory); if (configuration.ZipOldStatusFiles) { Directory.CreateDirectory(configuration.ZippedStatusFileDirectory); } using var runner = algorithmTunerBuilder.Invoke( configuration, argsParser.PathToTrainingInstanceFolder, argsParser.PathToTestInstanceFolder); if (argsParser.StartFromExistingStatus) { runner.UseStatusDump(Path.Combine(configuration.StatusFileDirectory, AlgorithmTunerConfiguration.FileName)); } if (configuration.EnableDataRecording) { runner.PrepareDataRecordDirectory(argsParser.StartFromExistingStatus); } // Run algorithm tuner. var bestParameters = runner.Run(); LoggingHelper.WriteLine( VerbosityLevel.Info, $"Best Configuration:{Environment.NewLine}{string.Join(Environment.NewLine, bestParameters.Select(keyValuePair => $"{keyValuePair.Key}: {keyValuePair.Value}"))}"); runner.CompleteAndExportGenerationHistory(); return(bestParameters); }
/// <summary> /// Entry point to the program. /// </summary> /// <param name="args">If 'master' is included as argument, a /// <see cref="Master{TTargetAlgorithm,TInstance,TResult}"/> is starting using the remaining arguments. /// Otherwise, a <see cref="Worker"/> is started with the provided arguments.</param> public static void Main(string[] args) { ProcessUtils.SetDefaultCultureInfo(CultureInfo.InvariantCulture); LoggingHelper.Configure($"parserLog_{ProcessUtils.GetCurrentProcessId()}.log"); // Parse arguments. var argsParser = new BbobRunnerConfigurationParser(); if (!ArgumentParserUtils.ParseArguments(argsParser, args)) { return; } var bbobConfig = argsParser.ConfigurationBuilder.Build(); if (argsParser.IsMaster) { switch (bbobConfig.GenericParameterization) { case GenericParameterization.RandomForestAverageRank: GenericBbobEntryPoint < GenomePredictionRandomForest <AverageRankStrategy>, GenomePredictionForestModel <GenomePredictionTree>, AverageRankStrategy> .Run(argsParser.AdditionalArguments, bbobConfig); break; case GenericParameterization.RandomForestReuseOldTrees: GenericBbobEntryPoint < GenomePredictionRandomForest <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(argsParser.AdditionalArguments, bbobConfig); break; case GenericParameterization.StandardRandomForest: case GenericParameterization.Default: default: GenericBbobEntryPoint < StandardRandomForestLearner <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(argsParser.AdditionalArguments, bbobConfig); break; } } else { Worker.Run(args); return; } }
/// <summary> /// Entry point to the program. /// </summary> /// <param name="args">If 'master' is included as argument, a /// <see cref="Master{TTargetAlgorithm,TInstance,TResult}"/> is starting using the remaining arguments. /// Otherwise, a <see cref="Worker"/> is started with the provided arguments.</param> public static void Main(string[] args) { LoggingHelper.Configure("bbobParserLog.txt"); var configParser = new BbobRunnerConfigurationParser(); if (!ArgumentParserUtils.ParseArguments(configParser, args)) { return; } var bbobConfig = configParser.ConfigurationBuilder.Build(); if (bbobConfig.IsMaster) { switch (bbobConfig.GenericParameterization) { case GenericParameterization.RandomForestAverageRank: GenericBbobEntryPoint < GenomePredictionRandomForest <AverageRankStrategy>, GenomePredictionForestModel <GenomePredictionTree>, AverageRankStrategy> .Run(configParser.AdditionalArguments, bbobConfig); break; case GenericParameterization.RandomForestReuseOldTrees: GenericBbobEntryPoint < GenomePredictionRandomForest <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(configParser.AdditionalArguments, bbobConfig); break; case GenericParameterization.StandardRandomForest: case GenericParameterization.Default: default: GenericBbobEntryPoint < StandardRandomForestLearner <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(configParser.AdditionalArguments, bbobConfig); break; } } else { Worker.Run(args); return; } }
/// <summary> /// Entry point to the program. /// </summary> /// <param name="args">If 'master' is included as argument, a /// <see cref="Master{TTargetAlgorithm,TInstance,TResult}"/> is starting using the remaining arguments. /// Otherwise, a <see cref="Worker"/> is started with the provided arguments.</param> public static void Main(string[] args) { LoggingHelper.Configure($"lingelingParserLog.txt"); // Parse arguments. var argsParser = new LingelingRunnerConfigurationParser(); if (!ArgumentParserUtils.ParseArguments(argsParser, args)) { return; } var config = argsParser.ConfigurationBuilder.Build(); // Start master or worker depending on arguments. if (config.IsMaster) { var bestParameters = config.GenericParameterization switch { GenericParameterization.RandomForestAverageRank => GenericLingelingEntryPoint < GenomePredictionRandomForest <AverageRankStrategy>, GenomePredictionForestModel <GenomePredictionTree>, AverageRankStrategy> .Run(argsParser.RemainingArguments, config), GenericParameterization.RandomForestReuseOldTrees => GenericLingelingEntryPoint < GenomePredictionRandomForest <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(argsParser.RemainingArguments, config), GenericParameterization.StandardRandomForest => GenericLingelingEntryPoint < StandardRandomForestLearner <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(argsParser.RemainingArguments, config), GenericParameterization.Default => GenericLingelingEntryPoint < StandardRandomForestLearner <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(argsParser.RemainingArguments, config), _ => GenericLingelingEntryPoint <StandardRandomForestLearner <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run(argsParser.RemainingArguments, config) }; Program.LogBestParameters(bestParameters, config); } else { Worker.Run(args); } }
private static void Main(string[] args) { LoggingHelper.Configure(); var cts = new CancellationTokenSource(); const string endpointName = "EnduranceTest"; Console.WriteLine("CTRL + C to stop test. Press Enter to continue."); Console.ReadLine(); Console.CancelKeyPress += (s, e) => { e.Cancel = true; cts.Cancel(); }; for (;;) { try { RunEndpointAsync(endpointName, cts.Token).Wait(cts.Token); break; } catch (OperationCanceledException) { Console.WriteLine("Test Cancelled. Press ENTER to continue."); Console.ReadLine(); break; } catch (Exception ex) { LoggingHelper.Log.Error(ex, "Caught RunEndpointAsync Exception"); } } }
/// <summary> /// Entry point to the program. /// </summary> /// <param name="args">Program arguments. Call the program with --help for more information.</param> public static void Main(string[] args) { ProcessUtils.SetDefaultCultureInfo(CultureInfo.InvariantCulture); LoggingHelper.Configure($"parserLog_{ProcessUtils.GetCurrentProcessId()}.log"); // Parse arguments. var argsParser = new ArgumentParser(); if (!ArgumentParserUtils.ParseArguments(argsParser, args)) { return; } // Start master or worker depending on arguments. if (argsParser.IsMaster) { Program.RunMaster(argsParser); } else { Worker.Run(argsParser.AdditionalArguments.ToArray()); } }
/// <summary> /// Initializes a new instance of the <see cref="GrayBoxSimulation{TTargetAlgorithm, TInstance, TResult}" /> class. /// </summary> /// <param name="configuration">The <see cref="AlgorithmTunerConfiguration"/>.</param> /// <param name="targetAlgorithmFactory">The <see cref="ITargetAlgorithmFactory{TTargetAlgorithm, TInstance, TResult}"/>.</param> /// <param name="customGrayBoxMethods">The <see cref="ICustomGrayBoxMethods{TResult}"/>.</param> /// <param name="runEvaluator">The <see cref="IRunEvaluator{TInstance, TResult}"/>.</param> /// <param name="parameterTree">The <see cref="ParameterTree"/>.</param> public GrayBoxSimulation( AlgorithmTunerConfiguration configuration, ITargetAlgorithmFactory <TTargetAlgorithm, TInstance, TResult> targetAlgorithmFactory, ICustomGrayBoxMethods <TResult> customGrayBoxMethods, IRunEvaluator <TInstance, TResult> runEvaluator, ParameterTree parameterTree) { ProcessUtils.SetDefaultCultureInfo(CultureInfo.InvariantCulture); this._configuration = configuration ?? throw new ArgumentNullException(nameof(configuration)); this._customGrayBoxMethods = customGrayBoxMethods ?? throw new ArgumentNullException(nameof(customGrayBoxMethods)); this._runEvaluator = runEvaluator ?? throw new ArgumentNullException(nameof(runEvaluator)); this._targetAlgorithmFactory = targetAlgorithmFactory ?? throw new ArgumentNullException(nameof(targetAlgorithmFactory)); this._parameterTree = parameterTree ?? throw new ArgumentNullException(nameof(parameterTree)); this._logFileDirectory = new DirectoryInfo(Path.Combine(this._configuration.DataRecordDirectoryPath, "GrayBoxSimulationLogFiles")); Directory.CreateDirectory(this._logFileDirectory.FullName); LoggingHelper.Configure( Path.Combine(this._logFileDirectory.FullName, $"consoleOutput_GrayBoxSimulation_{ProcessUtils.GetCurrentProcessId()}.log")); LoggingHelper.ChangeConsoleLoggingLevel(configuration.Verbosity); LoggingHelper.WriteLine(VerbosityLevel.Info, "Reading in and preprocessing data for gray box simulation."); if (!GrayBoxUtils.TryToReadDataRecordsFromDirectory( targetAlgorithmFactory, configuration.DataRecordDirectoryPath, 0, configuration.Generations - 1, out this._allDataRecords)) { throw new ArgumentException($"Cannot read data records from {configuration.DataRecordDirectoryPath}!"); } this.ReadGenerationCompositionFiles(); this.CreatePredictionDictionaryAndDataDictionary(); }
/// <summary> /// Entry point to the program. /// </summary> /// <param name="args">If 'master' is included as argument, a /// <see cref="Master{TTargetAlgorithm,TInstance,TResult}"/> is starting using the provided arguments. /// Otherwise, a <see cref="Worker"/> is started with the provided arguments.</param> public static void Main(string[] args) { ProcessUtils.SetDefaultCultureInfo(CultureInfo.InvariantCulture); LoggingHelper.Configure($"parserLog_{ProcessUtils.GetCurrentProcessId()}.log"); // Parse gurobi configuration. var gurobiParser = new GurobiRunnerConfigurationParser(); if (!ArgumentParserUtils.ParseArguments(gurobiParser, args)) { return; } if (gurobiParser.IsPostTuningRunner) { LoggingHelper.Configure($"consoleOutput_PostTuningRun_{ProcessUtils.GetCurrentProcessId()}.log"); // Parse and build tuner configuration. var masterArgumentParser = new MasterArgumentParser(); if (!ArgumentParserUtils.ParseArguments(masterArgumentParser, gurobiParser.AdditionalArguments.ToArray())) { return; } var tunerConfig = masterArgumentParser.ConfigurationBuilder.Build(); LoggingHelper.ChangeConsoleLoggingLevel(tunerConfig.Verbosity); // Build gurobi configuration. var gurobiConfig = Program.BuildGurobiConfigAndCheckThreadCount(gurobiParser.ConfigurationBuilder, tunerConfig); var gurobiRunnerFactory = new GurobiRunnerFactory(gurobiConfig, tunerConfig); var parameterTree = GurobiUtils.CreateParameterTree(); // Start post tuning runner. var parallelPostTuningRunner = new ParallelPostTuningRunner <GurobiRunner, InstanceSeedFile, GurobiResult>( tunerConfig, gurobiParser.PostTuningConfiguration, gurobiRunnerFactory, parameterTree); parallelPostTuningRunner.ExecutePostTuningRunsInParallel(); return; } if (gurobiParser.IsMaster) { Master <GurobiRunner, InstanceSeedFile, GurobiResult, StandardRandomForestLearner <ReuseOldTreesStrategy>, GenomePredictionForestModel <GenomePredictionTree>, ReuseOldTreesStrategy> .Run( args : gurobiParser.AdditionalArguments.ToArray(), algorithmTunerBuilder : (algorithmTunerConfig, pathToInstanceFolder, pathToTestInstanceFolder) => Program.BuildGurobiRunner( algorithmTunerConfig, pathToInstanceFolder, pathToTestInstanceFolder, gurobiParser.ConfigurationBuilder)); } else { Worker.Run(gurobiParser.AdditionalArguments.ToArray()); } }
/// <summary> /// Initializes a new instance of the <see cref="LoggingHelperTest"/> class. /// </summary> public LoggingHelperTest() { LoggingHelper.Configure(LoggingHelperTest.LogFile); }