public StatisticTrackerSchedulerManager(TaskPriority defaultPriority, long maxWaitForLowPriorityInMs, ThreadFactory threadFactory, int maxStatisticWindowSize, boolean accurateTime) { super(new NoThreadSchedulerStatisticTracker(defaultPriority, maxWaitForLowPriorityInMs, maxStatisticWindowSize, accurateTime), threadFactory); }
@Override public double getAverageExecutionDelay(TaskPriority priority) { return statisticTracker.getAverageExecutionDelay(priority); }
@Override public double getAverageExecutionDuration() { return statisticTracker.getAverageExecutionDuration(); }
@Test public void getWithPriorityAverageExecutionDurationNoInputTest() { NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); scheduler.execute(DoNothingRunnable.instance(), TaskPriority.Low); scheduler.tick(null); assertEquals(-1, scheduler.getAverageExecutionDuration(TaskPriority.High), 0); }
@Test public void resetCollectedStatsTest() { NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); TestRunnable lastRunnable = null; boolean flip = false; for (int i = 0; i < TEST_QTY; i++) { lastRunnable = new TestRunnable(1); if (flip) { scheduler.execute(lastRunnable, TaskPriority.High); flip = false; } else { scheduler.execute(lastRunnable, TaskPriority.Low); flip = true; } } scheduler.tick(null); // reset stats scheduler.resetCollectedStats(); assertEquals(-1, scheduler.getAverageExecutionDuration(), 0); for (TaskPriority p : TaskPriority.values()) { assertEquals(-1, scheduler.getAverageExecutionDelay(p), 0); } }
public void getPriorityAverageExecutionDelayNoInputTest(TaskPriority testPriority) { NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); switch (testPriority) { // submit with opposite priority case High: scheduler.execute(DoNothingRunnable.instance(), TaskPriority.Low); break; case Low: scheduler.execute(DoNothingRunnable.instance(), TaskPriority.High); break; default: throw new UnsupportedOperationException("Priority not implenented: " + testPriority); } // wait for task to finish now scheduler.tick(null); assertEquals(-1, scheduler.getAverageExecutionDelay(testPriority), 0); }
protected void getPriorityExecutionDelayPercentilesTest(TaskPriority priority) { NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); assertEquals(0, scheduler.getExecutionDelayPercentiles(90).get(90.), 0); scheduler.execute(new ClockUpdateRunnable(), priority); TestUtils.blockTillClockAdvances(); scheduler.tick(null); assertEquals(1, scheduler.getExecutionDelayPercentiles(90).get(90.), SLOW_MACHINE ? 50 : 20); }
@Test public void getExecutionDurationPercentilesTest() { NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); assertEquals(0, scheduler.getExecutionDurationPercentiles(50).get(50.), 0); scheduler.execute(new ClockUpdateRunnable()); scheduler.tick(null); assertEquals(1, scheduler.getExecutionDurationPercentiles(50).get(50.), 1); scheduler.execute(new ClockUpdateRunnable()); scheduler.execute(new ClockUpdateRunnable()); scheduler.execute(new ClockUpdateRunnable()); scheduler.execute(new ClockUpdateRunnable(DELAY_TIME)); scheduler.tick(null); assertEquals(1, scheduler.getExecutionDurationPercentiles(75).get(75.), 1); assertTrue(scheduler.getExecutionDurationPercentiles(90).get(90.) >= (DELAY_TIME-ALLOWED_VARIANCE)); }
@Test public void getLongRunningTasksQtyTest() { final NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); assertEquals(0, scheduler.getLongRunningTasksQty(-1)); scheduler.execute(new ClockUpdateRunnable() { @Override public void handleRunStart() { assertEquals(1, scheduler.getLongRunningTasksQty(-1)); assertEquals(0, scheduler.getLongRunningTasksQty(10)); } }); scheduler.tick(null); } }
@Test public void getTotalExecutionCountTest() { final int starvablePriorityCount = 1; final int lowPriorityCount = TEST_QTY; final int highPriorityCount = TEST_QTY * 2; NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); for (int i = 0; i < starvablePriorityCount; i++) { scheduler.execute(DoNothingRunnable.instance(), TaskPriority.Starvable); } for (int i = 0; i < lowPriorityCount; i++) { scheduler.execute(DoNothingRunnable.instance(), TaskPriority.Low); } for (int i = 0; i < highPriorityCount; i++) { scheduler.execute(DoNothingRunnable.instance(), TaskPriority.High); } // should not be very long after waiting above scheduler.tick(null); assertEquals(starvablePriorityCount, scheduler.getTotalExecutionCount(TaskPriority.Starvable)); assertEquals(lowPriorityCount, scheduler.getTotalExecutionCount(TaskPriority.Low)); assertEquals(highPriorityCount, scheduler.getTotalExecutionCount(TaskPriority.High)); assertEquals(starvablePriorityCount + lowPriorityCount + highPriorityCount, scheduler.getTotalExecutionCount(null)); }
@Test public void getAverageExecutionDurationNoInputTest() { NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); assertEquals(-1, scheduler.getAverageExecutionDuration(), 0); }
@Test public void getAverageExecutionDelayNoInputTest() { NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); assertEquals(-1, scheduler.getAverageExecutionDelay(), 0); }
@Test public void getLongRunningTasksWrappedFutureTest() { final NoThreadSchedulerStatisticTracker scheduler = new NoThreadSchedulerStatisticTracker(); scheduler.submit(new ClockUpdateRunnable() { @Override public void handleRunStart() { // even submitted (and thus wrapped in a future), we should get our direct reference assertTrue(scheduler.getLongRunningTasks(-1).get(0).getLeft() == this); } }); scheduler.tick(null); }
@Override public Map<Double, Long> getExecutionDelayPercentiles(TaskPriority priority, double... percentiles) { return statisticTracker.getExecutionDelayPercentiles(priority, percentiles); }
@Override public Map<Double, Long> getExecutionDurationPercentiles(TaskPriority priority, double... percentiles) { return statisticTracker.getExecutionDurationPercentiles(priority, percentiles); }
@Override public List<Long> getExecutionDelaySamples() { return statisticTracker.getExecutionDelaySamples(); }
@Override public List<Long> getExecutionDurationSamples(TaskPriority priority) { return statisticTracker.getExecutionDurationSamples(priority); }
@Override public long getTotalExecutionCount() { return statisticTracker.getTotalExecutionCount(); }
@Override public int getLongRunningTasksQty(long durationLimitMillis) { return statisticTracker.getLongRunningTasksQty(durationLimitMillis); }
@Override public List<Pair<Runnable, StackTraceElement[]>> getLongRunningTasks(long durationLimitMillis) { return statisticTracker.getLongRunningTasks(durationLimitMillis); }