/// <summary>
/// Starts user strategy execution
/// </summary>
/// <param name="runStrategy">Contains info for the strategy to be executed</param>
private void RunUserStrategy(RunStrategy runStrategy)
{
try
{
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Attempting to execute user strategy: " + runStrategy.Key, _type.FullName, "RunUserStrategy");
}
StrategyExecutor strategyExecutor;
if (_strategiesCollection.TryGetValue(runStrategy.Key, out strategyExecutor))
{
// Execute Strategy
strategyExecutor.ExecuteStrategy();
//Task.Factory.StartNew(() => strategyExecutor.ExecuteStrategy());
}
else
{
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("User strategy: " + runStrategy.Key + " not found.", _type.FullName, "RunUserStrategy");
}
}
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "RunUserStrategy");
}
}
public JemBenchmarkJobAttribute(
RunStrategy RunStrategy = RunStrategy.Throughput,
int TargetCount = DefaultValue,
int InvocationCount = DefaultValue,
int WarmupCount = DefaultValue
)
{
Job job = new Job()
.WithGcAllowVeryLargeObjects(true)
.WithId("JemBenchmark");
job.Env.Platform = Platform.X64;
job.Env.Runtime = Runtime.Core;
job.Env.Jit = Jit.RyuJit;
if (WarmupCountOverride.HasValue)
{
job.Run.WarmupCount = WarmupCountOverride.Value;
}
else if (WarmupCount != DefaultValue)
{
job.Run.WarmupCount = WarmupCount;
}
if (TargetCountOverride.HasValue)
{
job.Run.TargetCount = TargetCountOverride.Value;
}
else if (TargetCount != DefaultValue)
{
job.Run.TargetCount = TargetCount;
}
if (InvocationCountOverride.HasValue)
{
job.Run.InvocationCount = InvocationCountOverride.Value;
}
else if (InvocationCount != DefaultValue)
{
job.Run.InvocationCount = InvocationCount;
}
if (ColdStartOverride.HasValue)
{
job.Run.RunStrategy = ColdStartOverride.Value ? RunStrategy.ColdStart : RunStrategy.Throughput;
}
else
{
job.Run.RunStrategy = RunStrategy;
}
job.Infrastructure.Toolchain = new InProcessToolchain(TimeSpan.FromMinutes(TimeoutInMinutes), BenchmarkActionCodegen.ReflectionEmit, true);
Config = ManualConfig.CreateEmpty().With(job);
}
public SimpleJobAttribute(
RunStrategy runStrategy,
int launchCount = DefaultValue,
int warmupCount = DefaultValue,
int targetCount = DefaultValue,
string id = null
) : base(CreateJob(id, launchCount, warmupCount, targetCount, runStrategy))
{
}
public SimpleJobAttribute(
RunStrategy runStrategy,
int launchCount = DefaultValue,
int warmupCount = DefaultValue,
int targetCount = DefaultValue,
string id = null
) : base(CreateJob(id, launchCount, warmupCount, targetCount, runStrategy))
{
}
public static JobMutator CreateMutator(string id, int launchCount, int warmupCount, int targetCount,
RunStrategy strategy = Engines.RunStrategy.Throughput)
{
return(new JobMutator(id).Add(new CharacteristicSet(
Default.LaunchCount.Mutate(launchCount),
Default.WarmupCount.Mutate(warmupCount),
Default.TargetCount.Mutate(targetCount),
Default.RunStrategy.Mutate(strategy)
)));
}
public SimpleJobAttribute(
RunStrategy runStrategy,
int launchCount = DefaultValue,
int warmupCount = DefaultValue,
int targetCount = DefaultValue,
int invocationCount = DefaultValue,
string id = null,
bool isBaseline = false
) : base(CreateJob(id, launchCount, warmupCount, targetCount, invocationCount, runStrategy, isBaseline))
{
}
private static Job CreateJob(string id, int launchCount, int warmupCount, int targetCount, RunStrategy? runStrategy)
{
var job = new Job(id);
if (launchCount != DefaultValue)
job.Run.LaunchCount = launchCount;
if (warmupCount != DefaultValue)
job.Run.WarmupCount = warmupCount;
if (targetCount != DefaultValue)
job.Run.TargetCount = targetCount;
if (runStrategy != null)
job.Run.RunStrategy = runStrategy.Value;
return job.Freeze();
}
/// <summary>
/// Execute selected strategy
/// </summary>
private void RunSelectedStrategy(string key)
{
try
{
IPersistRepository <object> persistRepository = ContextRegistry.GetContext()["PersistRepository"] as IPersistRepository <object>;
PersistencePublisher.InitializeDisruptor(EnablePersistence, persistRepository);
if (Logger.IsInfoEnabled)
{
Logger.Info("Going to execute the selected strategy: ", _type.FullName, "RunSelectedStrategy");
}
// Create new instance to pass to event aggregator
RunStrategy runStrategy = new RunStrategy(key);
// Publish event to notify listeners
EventSystem.Publish <RunStrategy>(runStrategy);
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "RunSelectedStrategy");
}
}
// Run public static Job With(this Job job, RunStrategy strategy) => job.WithCore(j => j.Run.RunStrategy = strategy);
private IConfig CreateConfig(Jit jit, Platform platform, Runtime runtime, IDiagnoser disassemblyDiagnoser, RunStrategy runStrategy) => ManualConfig.CreateEmpty() .With(Job.Dry.With(jit).With(platform).With(runtime).With(runStrategy)) .With(DefaultConfig.Instance.GetLoggers().ToArray()) .With(DefaultColumnProviders.Instance) .With(disassemblyDiagnoser) .With(new OutputLogger(Output));
public static bool NeedsJitting(this RunStrategy runStrategy) => runStrategy == RunStrategy.Throughput;
// Run public static Job With(this Job job, RunStrategy strategy) => job.With(job.Run.RunStrategy.Mutate(strategy));
public virtual IStoppingCriteria CreateWarmup(Job job, IResolver resolver, IterationMode mode, RunStrategy runStrategy)
{
switch (mode)
{
case IterationMode.Overhead:
return(CreateWarmupOverhead());
case IterationMode.Workload:
return(CreateWarmupWorkload(job, resolver, runStrategy));
default:
throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
}
}
public virtual IStoppingCriteria CreateWarmupWorkload(Job job, IResolver resolver, RunStrategy runStrategy)
{
var count = job.ResolveValueAsNullable(RunMode.WarmupCountCharacteristic);
if (count.HasValue && count.Value != EngineResolver.ForceAutoWarmup || runStrategy == RunStrategy.Monitoring)
{
return(new FixedStoppingCriteria(count ?? 0));
}
int minIterationCount = job.ResolveValue(RunMode.MinWarmupIterationCountCharacteristic, resolver);
int maxIterationCount = job.ResolveValue(RunMode.MaxWarmupIterationCountCharacteristic, resolver);
return(new AutoWarmupStoppingCriteria(minIterationCount, maxIterationCount));
}
// Run public static Job With(this Job job, RunStrategy strategy) => job.WithCore(j => j.Run.RunStrategy = strategy);
