public IResult[] Execute(ITimes times, IParallelism parallelism)
{
IInstance[] input = this.instances;
while (true)
{
Log.Information("Executing {Case} {Times}", [email protected], times.Describe());
MinDurationVisitor visitor = new MinDurationVisitor();
IResult[] results = parallelism.Execute(input, times);
foreach (IResult result in results)
{
result.Data.Visit(visitor);
}
if (visitor.HasValue() == false || visitor.GetValue().TotalSeconds >= 1.0d)
{
return(results);
}
double ceiling = Math.Ceiling(1.2d / visitor.GetValue().TotalSeconds);
times = times.Multiply(Math.Max(2, (int)ceiling));
input = OptimizeOrder(results);
}
}
public ActionResult <IEnumerable <string> > Get()
{
ITimes time1 = container.ResolveNamed <ITimes>("SaoBento");
ITimes time2 = container.ResolveNamed <ITimes>("Corinthians");
return(new string[] { time1.Time, time2.Time });
}
public IResult[] Execute(ITimes times, IParallelism parallelism)
{
IInstance[] input = this.instances;
while (true)
{
Log.Information("Executing {Case} {Times}", [email protected], times.Describe());
MinDurationVisitor visitor = new MinDurationVisitor();
IResult[] results = parallelism.Execute(input, times);
foreach (IResult result in results)
{
result.Data.Visit(visitor);
}
if (visitor.HasValue() == false || visitor.GetValue().TotalSeconds >= 1.0d)
{
return results;
}
double ceiling = Math.Ceiling(1.2d / visitor.GetValue().TotalSeconds);
times = times.Multiply(Math.Max(2, (int)ceiling));
input = OptimizeOrder(results);
}
}
public IResult[] Execute(IInstance[] instances, ITimes times)
{
return
instances
.AsParallel()
.WithDegreeOfParallelism(this.degree)
.Select(Parallelism.CreateCallback(times))
.ToArray();
}
public IResult[] Execute(IInstance[] instances, ITimes times)
{
return
(instances
.AsParallel()
.WithDegreeOfParallelism(this.degree)
.Select(Parallelism.CreateCallback(times))
.ToArray());
}
public IReport Execute(ITimes times, IParallelism parallelism)
{
Report report = new Report();
foreach (IExecutionGroup @group in this.GroupInstances())
{
foreach (IResult result in @group.Execute(times, parallelism))
{
report.AddResult(result);
}
}
return report;
}
private IResultData Serialize <T>(IResource <T> resource, ISubject subject, ITimes times)
where T : class
{
times = resource.Multiply(times);
T instance = resource.GetInstance();
IRoutine routine = new Routine <T>(subject, instance);
TimeSpan started = AppDomain.CurrentDomain.MonitoringTotalProcessorTime;
times.Execute(routine);
TimeSpan ended = AppDomain.CurrentDomain.MonitoringTotalProcessorTime;
return(new MeasuredDurationResult(ended - started));
}
public IReport Execute(ITimes times, IParallelism parallelism)
{
Report report = new Report();
foreach (IExecutionGroup @group in this.GroupInstances())
{
foreach (IResult result in @group.Execute(times, parallelism))
{
report.AddResult(result);
}
}
return(report);
}
public IResultData Process <T>(IResource <T> resource, ISubject subject, ITimes times)
where T : class
{
IResultData result = null;
try
{
result = result ?? Validate <T>(resource, subject);
result = result ?? Deserialize <T>(resource, subject, times);
}
catch (Exception ex)
{
result = new FailedByExceptionResult(ex);
}
return(result);
}
public IResult Execute(ITimes times)
{
Log.Debug("New AppDomain {Subject}/{Procedure}", this.subject.Name, this.procedure.Name);
AppDomain domain = AppDomain.CreateDomain(String.Join("-", [email protected], this.subject.Name, this.procedure.Name));
try
{
Log.Information("Executing {Subject}/{Procedure} on thread {ThreadId}", this.subject.Name, this.procedure.Name);
Proxy proxy = (Proxy)domain.CreateInstanceFromAndUnwrap(this.GetType().Assembly.CodeBase, typeof(Proxy).FullName);
IResultData data = proxy.Execute(this.@case, this.procedure, this.subject, times);
IResult result = new Result(this.@case, this.procedure, this.subject, data);
return result;
}
finally
{
Log.Information("Executing {Subject}/{Procedure} on thread {ThreadId} completed", this.subject.Name, this.procedure.Name);
AppDomain.Unload(domain);
}
}
public IResult Execute(ITimes times)
{
Log.Debug("New AppDomain {Subject}/{Procedure}", this.subject.Name, this.procedure.Name);
AppDomain domain = AppDomain.CreateDomain(String.Join("-", [email protected], this.subject.Name, this.procedure.Name));
try
{
Log.Information("Executing {Subject}/{Procedure} on thread {ThreadId}", this.subject.Name, this.procedure.Name);
Proxy proxy = (Proxy)domain.CreateInstanceFromAndUnwrap(this.GetType().Assembly.CodeBase, typeof(Proxy).FullName);
IResultData data = proxy.Execute(this.@case, this.procedure, this.subject, times);
IResult result = new Result(this.@case, this.procedure, this.subject, data);
return(result);
}
finally
{
Log.Information("Executing {Subject}/{Procedure} on thread {ThreadId} completed", this.subject.Name, this.procedure.Name);
AppDomain.Unload(domain);
}
}
public ITimes Multiply(ITimes times)
{
return(times.Multiply(20000));
}
public IResultData Execute(IProcedure procedure, ISubject subject, ITimes times)
{
return(procedure.Process(this, subject, times));
}
private static Func<IInstance, IResult> CreateCallback(ITimes times)
{
return instance => instance.Execute(times);
}
public IResultData Execute(ICase @case, IProcedure procedure, ISubject subject, ITimes times)
{
return @case.Execute(procedure, subject, times);
}
// Note that the compiler thinks this is unused...
public DoSomethinger(IWhat a, ITimes b)
{
_a = a;
_b = b;
}
private static Func <IInstance, IResult> CreateCallback(ITimes times)
{
return(instance => instance.Execute(times));
}
public IResultData Execute(ICase @case, IProcedure procedure, ISubject subject, ITimes times)
{
return(@case.Execute(procedure, subject, times));
}
