/// <summary>
/// Constructs a termination condition.
/// </summary>
/// <param name="population">The creature population.</param>
/// <param name="condition">The termination condition to construct.</param>
/// <param name="param">The termination condition parameter.</param>
/// <returns>The constructed termination condition.</returns>
public static ITerminationCondition ConstructTerminationCondition(TerminationCondition condition, object param = null)
{
try
{
switch (condition)
{
case TerminationCondition.FitnessPlateau:
var plateauLength = Convert.ToUInt32(param);
return(new FitnessPlateau(plateauLength));
case TerminationCondition.FitnessThreshold:
var fitnessThreshold = Convert.ToUInt32(param);
return(new FitnessThreshold(fitnessThreshold));
case TerminationCondition.GenerationThreshold:
var generationThreshold = Convert.ToUInt32(param);
return(new GenerationThreshold(generationThreshold));
case TerminationCondition.Timer:
var stopTime = (TimeSpan)param;
return(new Timer(stopTime));
default:
throw new ArgumentException("Error! Invalid termination condition.");
}
}
catch
{
throw new ArgumentException("Error! Invalid constructor argument.");
}
}
/// <summary>
/// Constructor for AnnService
/// </summary>
/// <param name="network">Represents the Artificial Neural Network.</param>
/// <param name="terminationCondition">Represents the termination condition of
/// Artificial Neural Network.</param>
/// <param name="learningRate">Represents the learning rate of Artificial Neural Network.</param>
public AnnService(
ActivationNetwork network,
TerminationCondition terminationCondition,
double learningRate)
{
_network = network;
_learning = new BackPropagationLearning(network)
{
LearningRate = learningRate
};
_terminationCondition = terminationCondition;
}
/// <summary>
/// Starts the given process and polls it for completion. At every poll
/// interval, it asks the given <see cref="TerminationCondition"/> if this
/// process needs to be killed, and kills it if needs to.
///
/// If the CancellationToken is signalled while in this method, the process
/// will be killed.
///
/// The process should not be running when this method exists.
/// </summary>
/// <param name="termCondition">The termination condition for this process</param>
/// <param name="proc">The unstarted process</param>
private void RunProcess(TerminationCondition termCondition, Process proc)
{
ThrowIfCancellationRequested();
proc.Start();
Logger.LogDiagnostic($"Started process: {proc.ProcessName} (pid {proc.Id})");
// once we start the process, we need to periodically poll it.
try
{
do
{
Logger.LogDiagnostic("Polling process's exit status");
ThrowIfCancellationRequested();
if (termCondition.ShouldTerminate(proc))
{
Logger.LogDiagnostic($"ITerminationCondition has requested that this process be terminated");
// if we're asked to terminate the process, do so.
try
{
proc.Kill();
}
catch (InvalidOperationException)
{
// According to MSDN, this is what gets thrown when you try to kill a process
// that is not running.
// Since our process could have died between the time we last
// checked and now, just accept the exception and move on.
// The end result is that the process isn't running anymore.
}
break;
}
Logger.LogDiagnostic("ITerminationCondition has not requested that the process be terminated");
// sleep for a second before polling again.
Thread.Sleep(1000);
} while (!proc.HasExited);
Logger.LogDiagnostic("Process has exited, exiting poll loop");
}
catch (OperationCanceledException)
{
// kill the process if we get Ctrl-C'd.
proc.Kill();
throw;
}
}
public DeploymentModel Run(DeploymentModel initialDeploymentModel)
{
var initialChromosome = ChromosomeFactory.Create(initialDeploymentModel);
var population = InitialPopulationCreator.CreateInitialPopulation(initialChromosome, MinPopulationSize, MaxPopulationSize);
while (!TerminationCondition.HasReached(population, CurrentState))
{
var parents = SelectionStrategyStrategy.SelectChromosomes(MinPopulationSize, population).ToArray();
var offspring = Cross(parents).ToArray();
offspring = Mutate(offspring).ToArray();
population = ReinsertionStrategy.Reinsert(offspring, population);
foreach (var deployment in population.Deployments)
{
deployment.Fitness = FitnessEvaluator.Evaluate(deployment, Workload);
}
CurrentState.UpdateOnGenerationRan(population);
}
return(population.BestDeployment.ToDeploymentModel());
}
/// <summary>
/// Runs a single benchmark on a given version of CoreCLR and saves the results.
/// </summary>
/// <param name="version">The version of CoreCLR to run on</param>
/// <param name="bench">The benchmark to run</param>
/// <returns>The result from running the benchmark</returns>
private BenchmarkResult RunBenchmark(PreparedCoreClrVersion version, Benchmark bench)
{
ThrowIfCancellationRequested();
Logger.LogAlways($"Running benchmark {bench.Name}");
string folderName = Path.Combine(Directory.GetCurrentDirectory(), bench.Name);
Directory.CreateDirectory(folderName);
Directory.SetCurrentDirectory(folderName);
m_relativePath.Push(bench.Name);
try
{
using (TerminationCondition condition = ConstructTerminationCondition(bench))
{
ThrowIfCancellationRequested();
return(RunBenchmarkImplWithIterations(version, bench, condition));
}
}
finally
{
string upOneDir = Path.Combine(Directory.GetCurrentDirectory(), "..");
Directory.SetCurrentDirectory(upOneDir);
m_relativePath.Pop();
}
}
/// <summary>
/// Runs a single benchmark by spawning a process and monitoring it until
/// its exit.
/// </summary>
/// <param name="version">The coreclr version to test</param>
/// <param name="bench">The benchmark to run</param>
/// <param name="termCondition">The termination condition for this benchmark</param>
/// <returns>The result from running the benchmark</returns>
private IterationResult RunBenchmarkImpl(PreparedCoreClrVersion version, Benchmark bench, TerminationCondition termCondition)
{
ThrowIfCancellationRequested();
string coreRun = Path.Combine(version.Path, Utils.CoreRunName);
string arguments = bench.Arguments ?? "";
Debug.Assert(File.Exists(coreRun));
Debug.Assert(m_executableProbeMap.ContainsKey(bench));
string exePath = m_executableProbeMap[bench];
Process proc = new Process();
proc.StartInfo.FileName = coreRun;
proc.StartInfo.Arguments = exePath + " " + arguments;
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.CreateNoWindow = false;
foreach (var pair in bench.EnvironmentVariables)
{
proc.StartInfo.Environment[pair.Key] = pair.Value;
}
proc.StartInfo.Environment[Constants.ServerGCVariable] = m_run.Settings.ServerGC ? "1" : "0";
proc.StartInfo.Environment[Constants.ConcurrentGCVariable] = m_run.Settings.ConcurrentGC ? "1" : "0";
// run the process!
RunProcess(termCondition, proc);
Debug.Assert(proc.HasExited);
IterationResult result = new IterationResult();
result.DurationMsec = (long)(proc.ExitTime - proc.StartTime).TotalMilliseconds;
result.ExitCode = proc.ExitCode;
result.Pid = proc.Id;
ThrowIfCancellationRequested();
return(result);
}
/// <summary>
/// Runs a single iteration of a benchmark. If no iteration number if specified,
/// the benchmark is run once.
/// </summary>
/// <param name="version">The version of CoreCLR to run the benchmark on</param>
/// <param name="bench">The benchmark to run</param>
/// <param name="termCondition">The termination condition for this benchmark</param>
/// <returns>The result of running the benchmark</returns>
private BenchmarkResult RunBenchmarkImplWithIterations(PreparedCoreClrVersion version, Benchmark bench, TerminationCondition termCondition)
{
ThrowIfCancellationRequested();
Logger.LogAlways($"Running iterations for benchmark {bench.Name}");
BenchmarkResult result = new BenchmarkResult();
result.Benchmark = bench;
int iterations = bench.Iterations ?? 1;
for (int i = 0; i < iterations; i++)
{
Logger.LogAlways($"Beginning iteration {i} for benchmark {bench.Name}");
// we'll create subdirectories for every iteration.
string folderName = Path.Combine(Directory.GetCurrentDirectory(), i.ToString());
Directory.CreateDirectory(folderName);
Directory.SetCurrentDirectory(folderName);
m_relativePath.Push(i.ToString());
try
{
IterationResult iterResult;
string traceName = bench.Name + ".etl";
m_traceCollector.StartTrace(bench.Name + ".etl", m_run.CollectionLevel);
try
{
// we've got everything set up, time to run.
iterResult = RunBenchmarkImpl(version, bench, termCondition);
}
finally
{
m_traceCollector.StopTrace();
}
var currentRelativePath = Path.Combine(m_relativePath.Reverse().ToArray());
// TODO(segilles, xplat) adding .zip on the end is done by PerfView, perfcollect
// probably doesn't do this.
iterResult.TracePathLocation = Path.Combine(currentRelativePath, traceName + ".zip");
// write out the result json file that the analysis engine is expecting
File.WriteAllText(
Path.Combine(Directory.GetCurrentDirectory(), Constants.ResultJsonName),
JsonConvert.SerializeObject(iterResult, Formatting.Indented));
result.Iterations.Add(iterResult);
}
finally
{
string upOneDir = Path.Combine(Directory.GetCurrentDirectory(), "..");
Directory.SetCurrentDirectory(upOneDir);
m_relativePath.Pop();
}
}
// write out the benchmark json
File.WriteAllText(
Path.Combine(Directory.GetCurrentDirectory(), Constants.BenchmarkJsonName),
JsonConvert.SerializeObject(bench, Formatting.Indented));
ThrowIfCancellationRequested();
return(result);
}
public void SetTerminationCondition(TerminationCondition Condition)
{
mTerminationCondition = Condition;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void persistentCallToSecondary(org.neo4j.causalclustering.messaging.CatchUpRequest request, org.neo4j.causalclustering.catchup.CatchUpResponseAdaptor<StoreCopyFinishedResponse> copyHandler, org.neo4j.causalclustering.catchup.CatchupAddressProvider addressProvider, TerminationCondition terminationCondition) throws StoreCopyFailedException
private void PersistentCallToSecondary(CatchUpRequest request, CatchUpResponseAdaptor <StoreCopyFinishedResponse> copyHandler, CatchupAddressProvider addressProvider, TerminationCondition terminationCondition)
{
Org.Neo4j.causalclustering.helper.TimeoutStrategy_Timeout timeout = _backOffStrategy.newTimeout();
while (true)
{
try
{
AdvertisedSocketAddress address = addressProvider.Secondary();
_log.info(format("Sending request '%s' to '%s'", request, address));
StoreCopyFinishedResponse response = _catchUpClient.makeBlockingRequest(address, request, copyHandler);
if (SuccessfulRequest(response, request))
{
break;
}
}
catch (CatchUpClientException e)
{
Exception cause = e.InnerException;
if (cause is ConnectException)
{
_log.warn(cause.Message);
}
else
{
_log.warn(format("Request failed exceptionally '%s'.", request), e);
}
}
catch (CatchupAddressResolutionException e)
{
_log.warn("Unable to resolve address for '%s'. %s", request, e.Message);
}
terminationCondition();
AwaitAndIncrementTimeout(timeout);
}
}
/// <summary>
/// Creates a population and let it evolve until termination condition is reached.
/// </summary>
/// <param name="terminationCondition">Evolution termination condition evaluated on each new epoch</param>
/// <returns>The best solution found across the evolution</returns>
public ISolution EvolveUntil(TerminationCondition terminationCondition)
{
var rnd = RandomProvider.GetThreadRandom();
var shiftMatrix = MatrixBuilder.Build(this.problem);
var enumerator = new IncreasingRowsRandomColumns(this.problem.Days, this.problem.Slots);
var constraints = ConstraintsBuilder.Build(this.problem);
var chromoProcessor = new ChromosomeProcessor(shiftMatrix, enumerator, constraints);
var evaluator = new FitnessEvaluator(problem);
var fitnessFunction = new Fitness.FitnessFunction(chromoProcessor, evaluator, shiftMatrix);
var chromosomeLength = shiftMatrix.GetNumberOfUnforcedSlots();
const double crossoverProbability = 0.90;
const double mutationProbability = 0.05;
const int elitismPercentage = 5;
epochs = 1;
epochsWithoutFitnessImprovement = 0;
overallBestFitness = -1;
log.Debug("Starting population.");
var population = new Population();
for (var i = 0; i < populationSize; i++)
{
var c = new Double[chromosomeLength];
for (var k = 0; k < chromosomeLength; k++)
{
c[k] = rnd.NextDouble();
}
var ch = new Chromosome(c);
population.Solutions.Add(ch);
}
//create the genetic operators
var elite = new Elite(elitismPercentage);
var crossover = new Crossover(crossoverProbability, true)
{
CrossoverType = CrossoverType.SinglePoint
};
var mutation = new SwapMutate(mutationProbability);
//create the GA itself
var ga = new GeneticAlgorithm(population, fitnessFunction.Evaluate);
//subscribe to the GAs Generation Complete event
ga.OnGenerationComplete += Ga_OnGenerationComplete;
//add the operators to the ga process pipeline
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutation);
//run the GA
ga.Run((pop, currentGeneration, currentEvaluation) =>
{
return(terminationCondition(currentGeneration, epochsWithoutFitnessImprovement, population.MaximumFitness, population.AverageFitness));
});
population.GetTop(1)[0].Evaluate(fitnessFunction.Evaluate);
return(SolutionBuilder.Build(overallBestFitness, shiftMatrix, epochs * population.PopulationSize, this.problem.Items));
}
