internal StageDetails(StageExecution execution, VmPauseTimeAccumulator vmPauseTimeAccumulator)
{
this.Execution = execution;
this.VmPauseTimeAccumulator = vmPauseTimeAccumulator;
this.BaseVmPauseTime = vmPauseTimeAccumulator.PauseTime;
this.StartTime = currentTimeMillis();
}
private void saturate(StageExecution execution)
{
if (processors == 0)
{
return;
}
Random random = ThreadLocalRandom.current();
int maxThisCheck = random.Next(processors - 1) + 1;
//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())
{
int before = step.Processors(0);
if (random.nextBoolean() && step.Processors(-1) < before)
{
processors--;
if (--maxThisCheck == 0)
{
return;
}
}
}
}
private void RemoveProcessorFromPotentialIdleStep(StageExecution execution)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (org.neo4j.helpers.collection.Pair<Step<?>,float> fast : execution.stepsOrderedBy(org.neo4j.unsafe.impl.batchimport.stats.Keys.avg_processing_time, true))
foreach (Pair <Step <object>, float> fast in execution.StepsOrderedBy(Keys.avg_processing_time, true))
{
int numberOfProcessors = fast.First().processors(0);
if (numberOfProcessors == 1)
{
continue;
}
// Translate the factor compared to the next (slower) step and see if this step would still
// be faster if we decremented the processor count, with a slight conservative margin as well
// (0.8 instead of 1.0 so that we don't decrement and immediately become the bottleneck ourselves).
float factorWithDecrementedProcessorCount = fast.Other() * numberOfProcessors / (numberOfProcessors - 1);
if (factorWithDecrementedProcessorCount < 0.8f)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> fastestStep = fast.first();
Step <object> fastestStep = fast.First();
long doneBatches = Batches(fastestStep);
if (BatchesPassedSinceLastChange(fastestStep, doneBatches) >= _config.movingAverageSize())
{
int before = fastestStep.Processors(0);
if (fastestStep.Processors(-1) < before)
{
_lastChangedProcessors[fastestStep] = doneBatches;
return;
}
}
}
}
}
public override void Start(StageExecution execution)
{
foreach (ExecutionMonitor monitor in _monitors)
{
monitor.Start(execution);
}
}
public override void End(StageExecution execution, long totalTimeMillis)
{
foreach (ExecutionMonitor monitor in _monitors)
{
monitor.End(execution, totalTimeMillis);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRemoveCPUsFromWayTooFastStep()
public virtual void ShouldRemoveCPUsFromWayTooFastStep()
{
// GIVEN
Configuration config = config(10, 3);
// available processors = 2 is enough because it will see the fast step as only using 20% of a processor
// and it rounds down. So there's room for assigning one more.
DynamicProcessorAssigner assigner = new DynamicProcessorAssigner(config);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: ControlledStep<?> slowStep = spy(stepWithStats("slow", 1, avg_processing_time, 6L, done_batches, 10L).setProcessors(2));
ControlledStep <object> slowStep = spy(stepWithStats("slow", 1, avg_processing_time, 6L, done_batches, 10L).setProcessors(2));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: ControlledStep<?> fastStep = spy(stepWithStats("fast", 0, avg_processing_time, 2L, done_batches, 10L).setProcessors(2));
ControlledStep <object> fastStep = spy(stepWithStats("fast", 0, avg_processing_time, 2L, done_batches, 10L).setProcessors(2));
StageExecution execution = ExecutionOf(config, slowStep, fastStep);
assigner.Start(execution);
// WHEN checking
assigner.Check(execution);
// THEN one processor should be removed from the fast step
verify(fastStep, times(1)).processors(-1);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRemoveCPUsFromTooFastStepEvenIfThereIsAWayFaster()
public virtual void ShouldRemoveCPUsFromTooFastStepEvenIfThereIsAWayFaster()
{
// The point is that not only the fastest step is subject to have processors removed,
// it's the relationship between all pairs of steps. This is important since the DPA has got
// a max permit count of processors to assign, so reclaiming unnecessary assignments can
// have those be assigned to a more appropriate step instead, where it will benefit the Stage more.
// GIVEN
Configuration config = config(10, 3);
DynamicProcessorAssigner assigner = new DynamicProcessorAssigner(config);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> wayFastest = stepWithStats("wayFastest", 0, avg_processing_time, 50L, done_batches, 20L);
Step <object> wayFastest = stepWithStats("wayFastest", 0, avg_processing_time, 50L, done_batches, 20L);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> fast = spy(stepWithStats("fast", 0, avg_processing_time, 100L, done_batches, 20L).setProcessors(3));
Step <object> fast = spy(stepWithStats("fast", 0, avg_processing_time, 100L, done_batches, 20L).setProcessors(3));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> slow = stepWithStats("slow", 1, avg_processing_time, 220L, done_batches, 20L);
Step <object> slow = stepWithStats("slow", 1, avg_processing_time, 220L, done_batches, 20L);
StageExecution execution = ExecutionOf(config, slow, wayFastest, fast);
assigner.Start(execution);
// WHEN
assigner.Check(execution);
// THEN
verify(fast).processors(-1);
}
//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());
}
private long DoneBatches(StageExecution execution)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> step = org.neo4j.helpers.collection.Iterables.last(execution.steps());
Step <object> step = Iterables.last(execution.Steps());
return(step.Stats().stat(Keys.done_batches).asLong());
}
public override void Check(StageExecution execution)
{
ReprintProgressIfNecessary();
if (IncludeStage(execution))
{
UpdateProgress(ProgressOf(execution));
}
}
private StageExecution Execution(long doneBatches, Configuration config)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> step = ControlledStep.stepWithStats("Test", 0, done_batches, doneBatches);
Step <object> step = ControlledStep.StepWithStats("Test", 0, done_batches, doneBatches);
StageExecution execution = new StageExecution("Test", null, config, Collections.singletonList(step), 0);
return(execution);
}
public static void PrintSpectrum(StringBuilder builder, StageExecution execution, int width, DetailLevel additionalStatsLevel)
{
long[] values = values(execution);
long total = total(values);
// reduce the width with the known extra characters we know we'll print in and around the spectrum
width -= 2 + PROGRESS_WIDTH;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.helpers.collection.Pair<Step<?>,float> bottleNeck = execution.stepsOrderedBy(org.neo4j.unsafe.impl.batchimport.stats.Keys.avg_processing_time, false).iterator().next();
Pair <Step <object>, float> bottleNeck = execution.StepsOrderedBy(Keys.avg_processing_time, false).GetEnumerator().next();
QuantizedProjection projection = new QuantizedProjection(total, width);
long lastDoneBatches = 0;
int stepIndex = 0;
bool hasProgressed = false;
builder.Append('[');
//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())
{
StepStats stats = step.Stats();
if (!projection.Next(values[stepIndex]))
{
break; // odd though
}
long stepWidth = total == 0 && stepIndex == 0 ? width : projection.Step();
if (stepWidth > 0)
{
if (hasProgressed)
{
stepWidth--;
builder.Append('|');
}
bool isBottleNeck = bottleNeck.First() == step;
string name = (isBottleNeck ? "*" : "") + stats.ToString(additionalStatsLevel) + (step.Processors(0) > 1 ? "(" + step.Processors(0) + ")" : "");
int charIndex = 0; // negative value "delays" the text, i.e. pushes it to the right
char backgroundChar = step.Processors(0) > 1 ? '=' : '-';
for (int i = 0; i < stepWidth; i++, charIndex++)
{
char ch = backgroundChar;
if (charIndex >= 0 && charIndex < name.Length && charIndex < stepWidth)
{
ch = name[charIndex];
}
builder.Append(ch);
}
hasProgressed = true;
}
lastDoneBatches = stats.Stat(Keys.done_batches).asLong();
stepIndex++;
}
long progress = lastDoneBatches * execution.Config.batchSize();
builder.Append("]").Append(FitInProgress(progress));
}
protected internal virtual void RegisterProcessorCount(StageExecution execution)
{
IDictionary <string, int> byStage = new Dictionary <string, int>();
Processors[execution.Name()] = byStage;
//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())
{
byStage[step.Name()] = step.Processors(0);
}
}
public override void Check(StageExecution execution)
{
long currentTimeMillis = _clock.millis();
for (int i = 0; i < _monitors.Length; i++)
{
if (currentTimeMillis >= _endTimes[i])
{
_monitors[i].check(execution);
_endTimes[i] = _monitors[i].nextCheckTime();
}
}
}
private static long[] Values(StageExecution execution)
{
long[] values = new long[execution.Size()];
int i = 0;
//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())
{
values[i++] = Avg(step.Stats());
}
return(values);
}
private void Update(StageExecution execution)
{
long diff = 0;
long doneBatches = doneBatches(execution);
diff += doneBatches - _prevDoneBatches;
_prevDoneBatches = doneBatches;
if (diff > 0)
{
_totalReportedBatches += diff;
Progress(diff);
}
}
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 static long ProgressOf(StageExecution execution)
{
// First see if there's a "progress" stat
Stat progressStat = FindProgressStat(execution.Steps());
if (progressStat != null)
{
return(Weighted(execution.StageName, progressStat.AsLong()));
}
// No, then do the generic progress calculation by looking at "done_batches"
long doneBatches = last(execution.Steps()).stats().stat(Keys.done_batches).asLong();
int batchSize = execution.Config.batchSize();
return(Weighted(execution.StageName, doneBatches * batchSize));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldOrderStepsDescending()
public virtual void ShouldOrderStepsDescending()
{
// GIVEN
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Collection<Step<?>> steps = new java.util.ArrayList<>();
ICollection <Step <object> > steps = new List <Step <object> >();
steps.Add(stepWithAverageOf("step1", 0, 10));
steps.Add(stepWithAverageOf("step2", 0, 5));
steps.Add(stepWithAverageOf("step3", 0, 30));
steps.Add(stepWithAverageOf("step4", 0, 5));
StageExecution execution = new StageExecution("Test", null, DEFAULT, steps, ORDER_SEND_DOWNSTREAM);
// WHEN
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Iterator<org.neo4j.helpers.collection.Pair<Step<?>,float>> ordered = execution.stepsOrderedBy(org.neo4j.unsafe.impl.batchimport.stats.Keys.avg_processing_time, false).iterator();
IEnumerator <Pair <Step <object>, float> > ordered = execution.StepsOrderedBy(Keys.avg_processing_time, false).GetEnumerator();
// THEN
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.helpers.collection.Pair<Step<?>,float> slowest = ordered.next();
Pair <Step <object>, float> slowest = ordered.next();
assertEquals(3f, slowest.Other(), 0f);
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.helpers.collection.Pair<Step<?>,float> slower = ordered.next();
Pair <Step <object>, float> slower = ordered.next();
assertEquals(2f, slower.Other(), 0f);
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.helpers.collection.Pair<Step<?>,float> slow = ordered.next();
Pair <Step <object>, float> slow = ordered.next();
assertEquals(1f, slow.Other(), 0f);
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.helpers.collection.Pair<Step<?>,float> alsoSlow = ordered.next();
Pair <Step <object>, float> alsoSlow = ordered.next();
assertEquals(1f, alsoSlow.Other(), 0f);
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
assertFalse(ordered.hasNext());
}
public override void Start(StageExecution execution)
{
// Divide into 4 progress stages:
if (execution.StageName.Equals(DataImporter.NODE_IMPORT_NAME))
{
// Import nodes:
// - import nodes
// - prepare id mapper
InitializeNodeImport(_dependencyResolver.resolveDependency(typeof(Input_Estimates)), _dependencyResolver.resolveDependency(typeof(IdMapper)), _dependencyResolver.resolveDependency(typeof(BatchingNeoStores)));
}
else if (execution.StageName.Equals(DataImporter.RELATIONSHIP_IMPORT_NAME))
{
EndPrevious();
// Import relationships:
// - import relationships
InitializeRelationshipImport(_dependencyResolver.resolveDependency(typeof(Input_Estimates)), _dependencyResolver.resolveDependency(typeof(IdMapper)), _dependencyResolver.resolveDependency(typeof(BatchingNeoStores)));
}
else if (execution.StageName.Equals(NodeDegreeCountStage.NAME))
{
EndPrevious();
// Link relationships:
// - read node degrees
// - backward linking
// - node relationship linking
// - forward linking
InitializeLinking(_dependencyResolver.resolveDependency(typeof(BatchingNeoStores)), _dependencyResolver.resolveDependency(typeof(NodeRelationshipCache)), _dependencyResolver.resolveDependency(typeof(DataStatistics)));
}
else if (execution.StageName.Equals(CountGroupsStage.NAME))
{
EndPrevious();
// Misc:
// - relationship group defragmentation
// - counts store
InitializeMisc(_dependencyResolver.resolveDependency(typeof(BatchingNeoStores)), _dependencyResolver.resolveDependency(typeof(DataStatistics)));
}
else if (IncludeStage(execution))
{
_stashedProgress += _progress;
_progress = 0;
_newInternalStage = true;
}
_lastReportTime = currentTimeMillis();
}
public override void Check(StageExecution execution)
{
StringBuilder builder = new StringBuilder();
PrintSpectrum(builder, execution, _width, DetailLevel.IMPORTANT);
// add delta
long progress = last(execution.Steps()).stats().stat(Keys.done_batches).asLong() * execution.Config.batchSize();
long currentDelta = progress - _lastProgress;
builder.Append(" ∆").Append(FitInProgress(currentDelta));
// and remember progress to compare with next check
_lastProgress = progress;
// print it (overwriting the previous contents on this console line)
@out.print("\r" + builder);
}
/// <summary>
/// Executes a number of stages simultaneously, letting the given {@code monitor} get insight into the
/// execution.
/// </summary>
/// <param name="monitor"> <seealso cref="ExecutionMonitor"/> to get insight into the execution. </param>
/// <param name="stage"> <seealso cref="Stage stages"/> to execute. </param>
public static void SuperviseExecution(ExecutionMonitor monitor, Stage stage)
{
ExecutionSupervisor supervisor = new ExecutionSupervisor(Clocks.systemClock(), monitor);
StageExecution execution = null;
try
{
execution = stage.Execute();
supervisor.Supervise(execution);
}
finally
{
stage.Close();
if (execution != null)
{
execution.AssertHealthy();
}
}
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private void saturate(final int availableProcessor, StageExecution execution)
private void saturate(int availableProcessor, StageExecution execution)
{
Random random = ThreadLocalRandom.current();
int processors = availableProcessor;
for (int rounds = 0; rounds < availableProcessor && processors > 0; rounds++)
{
//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())
{
int before = step.Processors(0);
if (random.nextBoolean() && step.Processors(1) > before && --processors == 0)
{
return;
}
}
}
}
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;
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReceiveBatchesInOrder()
public virtual void ShouldReceiveBatchesInOrder()
{
// GIVEN
Configuration config = new Configuration_OverriddenAnonymousInnerClass(this, DEFAULT);
Stage stage = new Stage("Test stage", null, config, ORDER_SEND_DOWNSTREAM);
long batches = 1000;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long items = batches * config.batchSize();
long items = batches * config.BatchSize();
stage.Add(new PullingProducerStepAnonymousInnerClass(this, stage.Control(), config, items));
for (int i = 0; i < 3; i++)
{
stage.Add(new ReceiveOrderAssertingStep(stage.Control(), "Step" + i, config, i, false));
}
stage.Add(new ReceiveOrderAssertingStep(stage.Control(), "Final step", config, 0, true));
// WHEN
StageExecution execution = stage.Execute();
//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())
{
// we start off with two in each step
step.Processors(1);
}
(new ExecutionSupervisor(ExecutionMonitors.Invisible())).supervise(execution);
// THEN
//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())
{
assertEquals("For " + step, batches, step.Stats().stat(Keys.done_batches).asLong());
}
stage.Close();
}
private void AssignProcessorsToPotentialBottleNeck(StageExecution execution, int permits)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.helpers.collection.Pair<Step<?>,float> bottleNeck = execution.stepsOrderedBy(org.neo4j.unsafe.impl.batchimport.stats.Keys.avg_processing_time, false).iterator().next();
Pair <Step <object>, float> bottleNeck = execution.StepsOrderedBy(Keys.avg_processing_time, false).GetEnumerator().next();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> bottleNeckStep = bottleNeck.first();
Step <object> bottleNeckStep = bottleNeck.First();
long doneBatches = Batches(bottleNeckStep);
if (bottleNeck.Other() > 1.0f && BatchesPassedSinceLastChange(bottleNeckStep, doneBatches) >= _config.movingAverageSize())
{
// Assign 1/10th of the remaining permits. This will have processors being assigned more
// aggressively in the beginning of the run
int optimalProcessorIncrement = min(max(1, ( int )bottleNeck.Other() - 1), permits);
int before = bottleNeckStep.Processors(0);
int after = bottleNeckStep.Processors(max(optimalProcessorIncrement, permits / 10));
if (after > before)
{
_lastChangedProcessors[bottleNeckStep] = doneBatches;
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRemoveCPUsFromTooFastStepEvenIfNotAllPermitsAreUsed()
public virtual void ShouldRemoveCPUsFromTooFastStepEvenIfNotAllPermitsAreUsed()
{
// GIVEN
Configuration config = config(10, 20);
DynamicProcessorAssigner assigner = new DynamicProcessorAssigner(config);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> wayFastest = spy(stepWithStats("wayFastest", 0, avg_processing_time, 50L, done_batches, 20L).setProcessors(5));
Step <object> wayFastest = spy(stepWithStats("wayFastest", 0, avg_processing_time, 50L, done_batches, 20L).setProcessors(5));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> fast = spy(stepWithStats("fast", 0, avg_processing_time, 100L, done_batches, 20L).setProcessors(3));
Step <object> fast = spy(stepWithStats("fast", 0, avg_processing_time, 100L, done_batches, 20L).setProcessors(3));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Step<?> slow = stepWithStats("slow", 1, avg_processing_time, 220L, done_batches, 20L);
Step <object> slow = stepWithStats("slow", 1, avg_processing_time, 220L, done_batches, 20L);
StageExecution execution = ExecutionOf(config, slow, wayFastest, fast);
assigner.Start(execution);
// WHEN
assigner.Check(execution);
// THEN
verify(wayFastest).processors(-1);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAssignAdditionalCPUToBottleNeckStep()
public virtual void ShouldAssignAdditionalCPUToBottleNeckStep()
{
// GIVEN
Configuration config = config(10, 5);
DynamicProcessorAssigner assigner = new DynamicProcessorAssigner(config);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: ControlledStep<?> slowStep = stepWithStats("slow", 0, avg_processing_time, 10L, done_batches, 10L);
ControlledStep <object> slowStep = stepWithStats("slow", 0, avg_processing_time, 10L, done_batches, 10L);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: ControlledStep<?> fastStep = stepWithStats("fast", 0, avg_processing_time, 2L, done_batches, 10L);
ControlledStep <object> fastStep = stepWithStats("fast", 0, avg_processing_time, 2L, done_batches, 10L);
StageExecution execution = ExecutionOf(config, slowStep, fastStep);
assigner.Start(execution);
// WHEN
assigner.Check(execution);
// THEN
assertEquals(5, slowStep.Processors(0));
assertEquals(1, fastStep.Processors(0));
}
