//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void shouldBeAbleToProgressUnderStressfulProcessorChanges(int orderingGuarantees) throws Exception private void ShouldBeAbleToProgressUnderStressfulProcessorChanges(int orderingGuarantees) { // given int batches = 100; int processors = Runtime.Runtime.availableProcessors() * 10; Configuration config = new Configuration_OverriddenAnonymousInnerClass(this, Configuration.DEFAULT, processors); Stage stage = new StressStage(config, orderingGuarantees, batches); StageExecution execution = stage.Execute(); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<Step<?>> steps = asList(execution.steps()); IList <Step <object> > steps = new IList <Step <object> > { execution.Steps() }; steps[1].Processors(processors / 3); // when ThreadLocalRandom random = ThreadLocalRandom.current(); while (execution.StillExecuting()) { steps[2].Processors(random.Next(-2, 5)); Thread.Sleep(1); } execution.AssertHealthy(); // then assertEquals(batches, steps[steps.Count - 1].Stats().stat(Keys.done_batches).asLong()); }
public override void Check(StageExecution execution) { if (execution.StillExecuting()) { int permits = _availableProcessors - CountActiveProcessors(execution); if (permits > 0) { // Be swift at assigning processors to slow steps, i.e. potentially multiple per round AssignProcessorsToPotentialBottleNeck(execution, permits); } // Be a little more conservative removing processors from too fast steps RemoveProcessorFromPotentialIdleStep(execution); } }
/// <summary> /// Supervises <seealso cref="StageExecution"/>, provides continuous information to the <seealso cref="ExecutionMonitor"/> /// and returns when the execution is done or an error occurs, in which case an exception is thrown. /// /// Made synchronized to ensure that only one set of executions take place at any given time /// and also to make sure the calling thread goes through a memory barrier (useful both before and after execution). /// </summary> /// <param name="execution"> <seealso cref="StageExecution"/> instances to supervise simultaneously. </param> public virtual void Supervise(StageExecution execution) { lock (this) { long startTime = CurrentTimeMillis(); Start(execution); while (execution.StillExecuting()) { FinishAwareSleep(execution); _monitor.check(execution); } End(execution, CurrentTimeMillis() - startTime); } }
private int CountActiveProcessors(StageExecution execution) { float processors = 0; if (execution.StillExecuting()) { long highestAverage = Avg(execution.StepsOrderedBy(Keys.avg_processing_time, false).GetEnumerator().next().first()); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: for (Step<?> step : execution.steps()) foreach (Step <object> step in execution.Steps()) { // Calculate how active each step is so that a step that is very cheap // and idles a lot counts for less than 1 processor, so that bottlenecks can // "steal" some of its processing power. long avg = avg(step); float factor = ( float )avg / ( float )highestAverage; processors += factor * step.Processors(0); } } return(( int )Math.Round(processors, MidpointRounding.AwayFromZero)); }
private void FinishAwareSleep(StageExecution execution) { long endTime = _monitor.nextCheckTime(); while (CurrentTimeMillis() < endTime) { if (!execution.StillExecuting()) { break; } try { sleep(min(10, max(0, endTime - CurrentTimeMillis()))); } catch (InterruptedException e) { execution.Panic(e); break; } } }