aurora-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From s...@apache.org
Subject aurora git commit: Consider reserving for multiple tasks per preemption round
Date Tue, 24 Jan 2017 18:20:55 GMT
Repository: aurora
Updated Branches:
  refs/heads/master 86d8f2f04 -> 52ddce919


Consider reserving for multiple tasks per preemption round

To be fair, PendingTaskProcessor interleaves tasks from different groups.
However, this fairness comes at the price of increasing reservation time.
Even if reservations are being made for the same task group, the processor
would still restart iterating through slaves for each task instance. This
results in reevaluating all slaves already rejected in a previous search
before it finds a new viable candidate.

This patch improves `PendingTaskProcessor` performance by reducing slave
search/evaluation time, at the cost of reduced fairness.
`PendingTaskProcessor` now does reservation for a configurable maximum of
_N_ candidates per task group in each iteration over the list of slaves.

Bugs closed: AURORA-1867

Reviewed at https://reviews.apache.org/r/55357/


Project: http://git-wip-us.apache.org/repos/asf/aurora/repo
Commit: http://git-wip-us.apache.org/repos/asf/aurora/commit/52ddce91
Tree: http://git-wip-us.apache.org/repos/asf/aurora/tree/52ddce91
Diff: http://git-wip-us.apache.org/repos/asf/aurora/diff/52ddce91

Branch: refs/heads/master
Commit: 52ddce9194fc4196d2ae8d438d6f25b6d2c22cc4
Parents: 86d8f2f
Author: Mehrdad Nurolahzade <mehrdad@nurolahzade.com>
Authored: Tue Jan 24 19:20:37 2017 +0100
Committer: Stephan Erb <serb@apache.org>
Committed: Tue Jan 24 19:20:37 2017 +0100

----------------------------------------------------------------------
 .../aurora/benchmark/SchedulingBenchmarks.java  |  3 +-
 .../preemptor/PendingTaskProcessor.java         | 47 +++++++++++---
 .../scheduler/preemptor/PreemptorMetrics.java   | 10 ++-
 .../scheduler/preemptor/PreemptorModule.java    | 20 +++++-
 .../preemptor/PendingTaskProcessorTest.java     | 68 +++++++++++++++++++-
 .../preemptor/PreemptorModuleTest.java          |  3 +-
 6 files changed, 135 insertions(+), 16 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/aurora/blob/52ddce91/src/jmh/java/org/apache/aurora/benchmark/SchedulingBenchmarks.java
----------------------------------------------------------------------
diff --git a/src/jmh/java/org/apache/aurora/benchmark/SchedulingBenchmarks.java b/src/jmh/java/org/apache/aurora/benchmark/SchedulingBenchmarks.java
index fa37236..f2296a9 100644
--- a/src/jmh/java/org/apache/aurora/benchmark/SchedulingBenchmarks.java
+++ b/src/jmh/java/org/apache/aurora/benchmark/SchedulingBenchmarks.java
@@ -97,6 +97,7 @@ public class SchedulingBenchmarks {
   public abstract static class AbstractBase {
     private static final Amount<Long, Time> NO_DELAY = Amount.of(1L, Time.MILLISECONDS);
     private static final Amount<Long, Time> DELAY_FOREVER = Amount.of(30L, Time.DAYS);
+    private static final Integer BATCH_SIZE = 5;
     protected Storage storage;
     protected PendingTaskProcessor pendingTaskProcessor;
     private TaskScheduler taskScheduler;
@@ -117,7 +118,7 @@ public class SchedulingBenchmarks {
       // TODO(maxim): Find a way to DRY it and reuse existing modules instead.
       Injector injector = Guice.createInjector(
           new StateModule(),
-          new PreemptorModule(true, NO_DELAY, NO_DELAY),
+          new PreemptorModule(true, NO_DELAY, NO_DELAY, BATCH_SIZE),
           new TierModule(TaskTestUtil.TIER_CONFIG),
           new PrivateModule() {
             @Override

http://git-wip-us.apache.org/repos/asf/aurora/blob/52ddce91/src/main/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessor.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessor.java
b/src/main/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessor.java
index f59f3fd..dad1cbb 100644
--- a/src/main/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessor.java
+++ b/src/main/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessor.java
@@ -15,6 +15,7 @@ package org.apache.aurora.scheduler.preemptor;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -27,6 +28,7 @@ import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Function;
 import com.google.common.base.Functions;
 import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.cache.CacheBuilder;
@@ -81,6 +83,7 @@ public class PendingTaskProcessor implements Runnable {
   private final BiCache<PreemptionProposal, TaskGroupKey> slotCache;
   private final ClusterState clusterState;
   private final Clock clock;
+  private final Integer reservationBatchSize;
 
   /**
    * Binding annotation for the time interval after which a pending task becomes eligible
to
@@ -93,6 +96,15 @@ public class PendingTaskProcessor implements Runnable {
   @Target({ FIELD, PARAMETER, METHOD }) @Retention(RUNTIME)
   public @interface PreemptionDelay { }
 
+  /**
+   * Binding annotation for the maximum number of reservations for a task group to be processed
in
+   * a batch. Performing more reservations per task group improves preemption performance
at the
+   * cost of reduced preemption fairness.
+   */
+  @Qualifier
+  @Target({ FIELD, PARAMETER, METHOD }) @Retention(RUNTIME)
+  @interface ReservationBatchSize { }
+
   @Inject
   PendingTaskProcessor(
       Storage storage,
@@ -102,7 +114,8 @@ public class PendingTaskProcessor implements Runnable {
       @PreemptionDelay Amount<Long, Time> preemptionCandidacyDelay,
       BiCache<PreemptionProposal, TaskGroupKey> slotCache,
       ClusterState clusterState,
-      Clock clock) {
+      Clock clock,
+      @ReservationBatchSize Integer reservationBatchSize) {
 
     this.storage = requireNonNull(storage);
     this.offerManager = requireNonNull(offerManager);
@@ -112,6 +125,7 @@ public class PendingTaskProcessor implements Runnable {
     this.slotCache = requireNonNull(slotCache);
     this.clusterState = requireNonNull(clusterState);
     this.clock = requireNonNull(clock);
+    this.reservationBatchSize = requireNonNull(reservationBatchSize);
   }
 
   @Timed("pending_task_processor_run")
@@ -145,13 +159,19 @@ public class PendingTaskProcessor implements Runnable {
       LoadingCache<IJobKey, AttributeAggregate> jobStates = attributeCache(store);
       List<TaskGroupKey> pendingGroups = fetchIdlePendingGroups(store);
       Iterator<TaskGroupKey> groups = Iterators.consumingIterator(pendingGroups.iterator());
+      TaskGroupKey lastGroup = null;
+      Iterator<String> slaveIterator = allSlaves.iterator();
+
       while (!pendingGroups.isEmpty()) {
         boolean matched = false;
         TaskGroupKey group = groups.next();
         ITaskConfig task = group.getTask();
 
         metrics.recordPreemptionAttemptFor(task);
-        Iterator<String> slaveIterator = allSlaves.iterator();
+        // start over only if a different task group is being processed
+        if (!group.equals(lastGroup)) {
+          slaveIterator = allSlaves.iterator();
+        }
         while (slaveIterator.hasNext()) {
           String slaveId = slaveIterator.next();
           Optional<ImmutableSet<PreemptionVictim>> candidates =
@@ -175,7 +195,9 @@ public class PendingTaskProcessor implements Runnable {
           // No slot found for the group -> remove group and reset group iterator.
           pendingGroups.removeAll(ImmutableSet.of(group));
           groups = Iterators.consumingIterator(pendingGroups.iterator());
+          metrics.recordUnmatchedTask();
         }
+        lastGroup = group;
       }
       return null;
     });
@@ -187,25 +209,34 @@ public class PendingTaskProcessor implements Runnable {
             .filter(Predicates.and(isIdleTask, Predicates.not(hasCachedSlot)))
             .transform(Functions.compose(ASSIGNED_TO_GROUP_KEY, IScheduledTask::getAssignedTask)));
 
-    return getPreemptionSequence(taskGroupCounts);
+    return getPreemptionSequence(taskGroupCounts, reservationBatchSize);
   }
 
   /**
-   * Creates execution sequence for pending task groups by interleaving their unique occurrences.
-   * For example: {G1, G1, G1, G2, G2} will be converted into {G1, G2, G1, G2, G1}.
+   * Creates execution sequence for pending task groups by interleaving batches of requested
size of
+   * their occurrences. For example: {G1, G1, G1, G2, G2} with batch size of 2 task per group
will
+   * be converted into {G1, G1, G2, G2, G1}.
    *
    * @param groups Multiset of task groups.
+   * @param batchSize The batch size of tasks from each group to sequence together.
    * @return A task group execution sequence.
    */
-  private static List<TaskGroupKey> getPreemptionSequence(Multiset<TaskGroupKey>
groups) {
+  @VisibleForTesting
+  static List<TaskGroupKey> getPreemptionSequence(
+      Multiset<TaskGroupKey> groups,
+      int batchSize) {
+
+    Preconditions.checkArgument(batchSize > 0, "batchSize should be positive.");
+
     Multiset<TaskGroupKey> mutableGroups = HashMultiset.create(groups);
     List<TaskGroupKey> instructions = Lists.newLinkedList();
     Set<TaskGroupKey> keys = ImmutableSet.copyOf(groups.elementSet());
     while (!mutableGroups.isEmpty()) {
       for (TaskGroupKey key : keys) {
         if (mutableGroups.contains(key)) {
-          instructions.add(key);
-          mutableGroups.remove(key);
+          int elementCount = mutableGroups.remove(key, batchSize);
+          int removedCount = Math.min(elementCount, batchSize);
+          instructions.addAll(Collections.nCopies(removedCount, key));
         }
       }
     }

http://git-wip-us.apache.org/repos/asf/aurora/blob/52ddce91/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorMetrics.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorMetrics.java b/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorMetrics.java
index 67822ca..662aa2d 100644
--- a/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorMetrics.java
+++ b/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorMetrics.java
@@ -37,6 +37,9 @@ public class PreemptorMetrics {
   @VisibleForTesting
   static final String TASK_PROCESSOR_RUN_NAME = "preemptor_task_processor_runs";
 
+  @VisibleForTesting
+  static final String UNMATCHED_TASKS = "preemptor_unmatched_tasks";
+
   private volatile boolean exported = false;
   private final CachedCounters counters;
 
@@ -72,7 +75,8 @@ public class PreemptorMetrics {
         slotValidationStatName(true),
         slotValidationStatName(false),
         MISSING_ATTRIBUTES_NAME,
-        TASK_PROCESSOR_RUN_NAME);
+        TASK_PROCESSOR_RUN_NAME,
+        UNMATCHED_TASKS);
     for (String stat : allStats) {
       counters.get(stat);
     }
@@ -117,6 +121,10 @@ public class PreemptorMetrics {
     increment(slotSearchStatName(result.isPresent(), task.isProduction()));
   }
 
+  void recordUnmatchedTask() {
+    increment(UNMATCHED_TASKS);
+  }
+
   void recordSlotValidationResult(Optional<?> result) {
     increment(slotValidationStatName(result.isPresent()));
   }

http://git-wip-us.apache.org/repos/asf/aurora/blob/52ddce91/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorModule.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorModule.java b/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorModule.java
index 23d1c12..66d2029 100644
--- a/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorModule.java
+++ b/src/main/java/org/apache/aurora/scheduler/preemptor/PreemptorModule.java
@@ -25,6 +25,7 @@ import com.google.inject.TypeLiteral;
 
 import org.apache.aurora.common.args.Arg;
 import org.apache.aurora.common.args.CmdLine;
+import org.apache.aurora.common.args.constraints.Positive;
 import org.apache.aurora.common.quantity.Amount;
 import org.apache.aurora.common.quantity.Time;
 import org.apache.aurora.scheduler.SchedulerServicesModule;
@@ -59,23 +60,35 @@ public class PreemptorModule extends AbstractModule {
   private static final Arg<Amount<Long, Time>> PREEMPTION_SLOT_SEARCH_INTERVAL
=
       Arg.create(Amount.of(1L, Time.MINUTES));
 
+  @Positive
+  @CmdLine(name = "preemption_reservation_max_batch_size",
+      help = "The maximum number of reservations for a task group to be made in a batch.")
+  private static final Arg<Integer> RESERVATION_MAX_BATCH_SIZE = Arg.create(5);
+
   private final boolean enablePreemptor;
   private final Amount<Long, Time> preemptionDelay;
   private final Amount<Long, Time> slotSearchInterval;
+  private final Integer reservationBatchSize;
 
   @VisibleForTesting
   public PreemptorModule(
       boolean enablePreemptor,
       Amount<Long, Time> preemptionDelay,
-      Amount<Long, Time> slotSearchInterval) {
+      Amount<Long, Time> slotSearchInterval,
+      Integer reservationBatchSize) {
 
     this.enablePreemptor = enablePreemptor;
     this.preemptionDelay = requireNonNull(preemptionDelay);
     this.slotSearchInterval = requireNonNull(slotSearchInterval);
+    this.reservationBatchSize = requireNonNull(reservationBatchSize);
   }
 
   public PreemptorModule() {
-    this(ENABLE_PREEMPTOR.get(), PREEMPTION_DELAY.get(), PREEMPTION_SLOT_SEARCH_INTERVAL.get());
+    this(
+        ENABLE_PREEMPTOR.get(),
+        PREEMPTION_DELAY.get(),
+        PREEMPTION_SLOT_SEARCH_INTERVAL.get(),
+        RESERVATION_MAX_BATCH_SIZE.get());
   }
 
   @Override
@@ -98,6 +111,9 @@ public class PreemptorModule extends AbstractModule {
               new BiCacheSettings(PREEMPTION_SLOT_HOLD_TIME.get(), "preemption_slot_cache_size"));
           bind(new TypeLiteral<BiCache<PreemptionProposal, TaskGroupKey>>() {
})
               .in(Singleton.class);
+          bind(new TypeLiteral<Integer>() { })
+              .annotatedWith(PendingTaskProcessor.ReservationBatchSize.class)
+              .toInstance(reservationBatchSize);
           bind(PendingTaskProcessor.class).in(Singleton.class);
           bind(ClusterState.class).to(ClusterStateImpl.class);
           bind(ClusterStateImpl.class).in(Singleton.class);

http://git-wip-us.apache.org/repos/asf/aurora/blob/52ddce91/src/test/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessorTest.java
b/src/test/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessorTest.java
index d11ae58..5c115f3 100644
--- a/src/test/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessorTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/preemptor/PendingTaskProcessorTest.java
@@ -18,6 +18,8 @@ import java.util.Arrays;
 import javax.annotation.Nullable;
 
 import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMultiset;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Multimaps;
@@ -51,6 +53,7 @@ import org.junit.Test;
 
 import static org.apache.aurora.gen.ScheduleStatus.PENDING;
 import static org.apache.aurora.scheduler.preemptor.PreemptorMetrics.TASK_PROCESSOR_RUN_NAME;
+import static org.apache.aurora.scheduler.preemptor.PreemptorMetrics.UNMATCHED_TASKS;
 import static org.apache.aurora.scheduler.preemptor.PreemptorMetrics.attemptsStatName;
 import static org.apache.aurora.scheduler.preemptor.PreemptorMetrics.slotSearchStatName;
 import static org.easymock.EasyMock.anyObject;
@@ -66,11 +69,14 @@ public class PendingTaskProcessorTest extends EasyMockTest {
   private static final String SLAVE_ID_2 = "slave_id_2";
   private static final IJobKey JOB_A = JobKeys.from("role_a", "env", "job_a");
   private static final IJobKey JOB_B = JobKeys.from("role_b", "env", "job_b");
+  private static final IJobKey JOB_C = JobKeys.from("role_c", "env", "job_c");
   private static final IScheduledTask TASK_A = makeTask(JOB_A, SLAVE_ID_1, "id1");
   private static final IScheduledTask TASK_B = makeTask(JOB_B, SLAVE_ID_2, "id2");
+  private static final IScheduledTask TASK_C = makeTask(JOB_C, SLAVE_ID_2, "id3");
   private static final PreemptionProposal SLOT_A = createPreemptionProposal(TASK_A, SLAVE_ID_1);
   private static final Amount<Long, Time> PREEMPTION_DELAY = Amount.of(30L, Time.SECONDS);
   private static final Amount<Long, Time> EXPIRATION = Amount.of(10L, Time.MINUTES);
+  private static final Integer RESERVATION_BATCH_SIZE = 5;
 
   private StorageTestUtil storageUtil;
   private OfferManager offerManager;
@@ -103,7 +109,8 @@ public class PendingTaskProcessorTest extends EasyMockTest {
         PREEMPTION_DELAY,
         slotCache,
         clusterState,
-        clock);
+        clock,
+        RESERVATION_BATCH_SIZE);
   }
 
   @Test
@@ -125,6 +132,7 @@ public class PendingTaskProcessorTest extends EasyMockTest {
     assertEquals(2L, statsProvider.getLongValue(attemptsStatName(true)));
     assertEquals(2L, statsProvider.getLongValue(slotSearchStatName(true, true)));
     assertEquals(0L, statsProvider.getLongValue(slotSearchStatName(false, true)));
+    assertEquals(0L, statsProvider.getLongValue(UNMATCHED_TASKS));
     assertEquals(2L, statsProvider.getLongValue(CACHE_STAT));
   }
 
@@ -145,6 +153,7 @@ public class PendingTaskProcessorTest extends EasyMockTest {
     assertEquals(1L, statsProvider.getLongValue(attemptsStatName(true)));
     assertEquals(0L, statsProvider.getLongValue(slotSearchStatName(true, true)));
     assertEquals(1L, statsProvider.getLongValue(slotSearchStatName(false, true)));
+    assertEquals(1L, statsProvider.getLongValue(UNMATCHED_TASKS));
   }
 
   @Test
@@ -164,6 +173,7 @@ public class PendingTaskProcessorTest extends EasyMockTest {
     assertEquals(0L, statsProvider.getLongValue(attemptsStatName(true)));
     assertEquals(0L, statsProvider.getLongValue(slotSearchStatName(true, true)));
     assertEquals(0L, statsProvider.getLongValue(slotSearchStatName(false, true)));
+    assertEquals(0L, statsProvider.getLongValue(UNMATCHED_TASKS));
   }
 
   @Test
@@ -197,10 +207,11 @@ public class PendingTaskProcessorTest extends EasyMockTest {
     assertEquals(2L, statsProvider.getLongValue(slotSearchStatName(true, true)));
 
     // TODO(wfarner): This test depends on the iteration order of a hash set (the set containing
-    // task groups), and as a result this stat could be 1 or 2 depending on which group is
+    // task groups), and as a result this stat could be 0 or 2 depending on which group is
     // evaluated first.
-    assertTrue(ImmutableSet.of(1L, 2L).contains(
+    assertTrue(ImmutableSet.of(0L, 2L).contains(
         statsProvider.getLongValue(slotSearchStatName(false, true))));
+    assertEquals(1L, statsProvider.getLongValue(UNMATCHED_TASKS));
     assertEquals(2L, statsProvider.getLongValue(CACHE_STAT));
   }
 
@@ -216,6 +227,57 @@ public class PendingTaskProcessorTest extends EasyMockTest {
     assertEquals(0L, statsProvider.getLongValue(attemptsStatName(true)));
     assertEquals(0L, statsProvider.getLongValue(slotSearchStatName(true, true)));
     assertEquals(0L, statsProvider.getLongValue(slotSearchStatName(false, true)));
+    assertEquals(0L, statsProvider.getLongValue(UNMATCHED_TASKS));
+  }
+
+  @Test
+  public void testGetPreemptionSequence() {
+    TaskGroupKey a = group(TASK_A);
+    TaskGroupKey b = group(TASK_B);
+    TaskGroupKey c = group(TASK_C);
+
+    control.replay();
+
+    assertEquals(
+        ImmutableList.of(),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(), 2));
+    assertEquals(
+        ImmutableList.of(a),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a), 3));
+    assertEquals(
+        ImmutableList.of(a, a, a),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a, a, a), 5));
+    assertEquals(
+        ImmutableList.of(a, a, a),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a, a, a), 2));
+    assertEquals(
+        ImmutableList.of(a, b, a, b, a),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a, a, a, b, b), 1));
+    assertEquals(
+        ImmutableList.of(a, a, b, b, a),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a, a, a, b, b), 2));
+    assertEquals(
+        ImmutableList.of(a, a, a, b, b),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a, a, a, b, b), 3));
+    assertEquals(
+        ImmutableList.of(a, a, a, b, b),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a, a, a, b, b), 5));
+    assertEquals(
+        ImmutableList.of(a, a, b, b, a, a, a),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a, a, a, a, a, b,
b), 2));
+    assertEquals(
+        ImmutableList.of(a, b, c, b, c),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a, b, b, c, c), 1));
+    assertEquals(
+        ImmutableList.of(a, b, b, c, c),
+        PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(a, b, b, c, c), 2));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testGetPreemptionSequenceInvalidArgument() {
+    control.replay();
+
+    PendingTaskProcessor.getPreemptionSequence(ImmutableMultiset.of(), 0);
   }
 
   private Multimap<String, PreemptionVictim> getVictims(IScheduledTask... tasks) {

http://git-wip-us.apache.org/repos/asf/aurora/blob/52ddce91/src/test/java/org/apache/aurora/scheduler/preemptor/PreemptorModuleTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/preemptor/PreemptorModuleTest.java
b/src/test/java/org/apache/aurora/scheduler/preemptor/PreemptorModuleTest.java
index 67b6d69..da064e3 100644
--- a/src/test/java/org/apache/aurora/scheduler/preemptor/PreemptorModuleTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/preemptor/PreemptorModuleTest.java
@@ -69,7 +69,8 @@ public class PreemptorModuleTest extends EasyMockTest {
     Injector injector = createInjector(new PreemptorModule(
         false,
         Amount.of(0L, Time.SECONDS),
-        Amount.of(0L, Time.SECONDS)));
+        Amount.of(0L, Time.SECONDS),
+        5));
 
     control.replay();
 


Mime
View raw message