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