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)); }