Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 4FD6A200D08 for ; Thu, 7 Sep 2017 01:46:11 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id 4E4AE160D2A; Wed, 6 Sep 2017 23:46:11 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 58EE71609DB for ; Thu, 7 Sep 2017 01:46:09 +0200 (CEST) Received: (qmail 75258 invoked by uid 500); 6 Sep 2017 23:46:07 -0000 Mailing-List: contact common-commits-help@hadoop.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Delivered-To: mailing list common-commits@hadoop.apache.org Received: (qmail 75245 invoked by uid 99); 6 Sep 2017 23:46:07 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 06 Sep 2017 23:46:07 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 02D1BE053D; Wed, 6 Sep 2017 23:46:06 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: subru@apache.org To: common-commits@hadoop.apache.org Date: Wed, 06 Sep 2017 23:46:06 -0000 Message-Id: X-Mailer: ASF-Git Admin Mailer Subject: [1/3] hadoop git commit: YARN-5328. Plan/ResourceAllocation data structure enhancements required to support recurring reservations in ReservationSystem. archived-at: Wed, 06 Sep 2017 23:46:11 -0000 Repository: hadoop Updated Branches: refs/heads/trunk e3345e985 -> b6e7d1369 http://git-wip-us.apache.org/repos/asf/hadoop/blob/b6e7d136/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestInMemoryPlan.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestInMemoryPlan.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestInMemoryPlan.java index bc98e2f..03569d4 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestInMemoryPlan.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestInMemoryPlan.java @@ -40,6 +40,7 @@ import org.apache.hadoop.yarn.server.resourcemanager.reservation.planning.Planne import org.apache.hadoop.yarn.server.resourcemanager.reservation.planning.ReservationAgent; import org.apache.hadoop.yarn.server.resourcemanager.scheduler.QueueMetrics; import org.apache.hadoop.yarn.util.Clock; +import org.apache.hadoop.yarn.util.UTCClock; import org.apache.hadoop.yarn.util.resource.DefaultResourceCalculator; import org.apache.hadoop.yarn.util.resource.ResourceCalculator; import org.junit.After; @@ -47,6 +48,10 @@ import org.junit.Assert; import org.junit.Before; import org.junit.Test; +/** + * Testing the class {@link InMemoryPlan}. + */ +@SuppressWarnings("checkstyle:nowhitespaceafter") public class TestInMemoryPlan { private String user = "yarn"; @@ -62,6 +67,7 @@ public class TestInMemoryPlan { private ReservationAgent agent; private Planner replanner; private RMContext context; + private long maxPeriodicity; @Before public void setUp() throws PlanningException { @@ -72,7 +78,7 @@ public class TestInMemoryPlan { clock = mock(Clock.class); queueMetrics = mock(QueueMetrics.class); - policy = mock(SharingPolicy.class); + policy = new NoOverCommitPolicy(); replanner = mock(Planner.class); when(clock.getTime()).thenReturn(1L); @@ -95,15 +101,41 @@ public class TestInMemoryPlan { @Test public void testAddReservation() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = - ReservationSystemTestUtil.getNewReservationId(); + ReservationSystemTestUtil.getNewReservationId(); int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; - ReservationAllocation rAllocation = createReservationAllocation - (reservationID, start, alloc); + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); + Assert.assertNull(plan.getReservationById(reservationID)); + try { + plan.addReservation(rAllocation, false); + } catch (PlanningException e) { + Assert.fail(e.getMessage()); + } + doAssertions(plan, rAllocation); + checkAllocation(plan, alloc, start, 0); + } + + @Test + public void testAddPeriodicReservation() throws PlanningException { + + maxPeriodicity = 100; + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, maxPeriodicity, + context, new UTCClock()); + + ReservationId reservationID = + ReservationSystemTestUtil.getNewReservationId(); + int[] alloc = { 10, 50 }; + int start = 10; + long period = 20; + ReservationAllocation rAllocation = createReservationAllocation( + reservationID, start, alloc, String.valueOf(period)); + // use periodicity of 1hr + rAllocation.setPeriodicity(period); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -111,32 +143,54 @@ public class TestInMemoryPlan { Assert.fail(e.getMessage()); } doAssertions(plan, rAllocation); - checkAllocation(plan, alloc, start); + checkAllocation(plan, alloc, start, period); + + RLESparseResourceAllocation available = + plan.getAvailableResourceOverTime(user, reservationID, 150, 330, 50); + System.out.println(available); } - private void checkAllocation(Plan plan, int[] alloc, int start) { + private void checkAllocation(Plan plan, int[] alloc, int start, + long periodicity) { + long end = start + alloc.length; + if (periodicity > 0) { + end = end + maxPeriodicity; + } RLESparseResourceAllocation userCons = - plan.getConsumptionForUserOverTime(user, start, start + alloc.length); + plan.getConsumptionForUserOverTime(user, start, end * 3); for (int i = 0; i < alloc.length; i++) { - Assert.assertEquals(Resource.newInstance(1024 * (alloc[i]), (alloc[i])), - plan.getTotalCommittedResources(start + i)); - Assert.assertEquals(Resource.newInstance(1024 * (alloc[i]), (alloc[i])), - userCons.getCapacityAtTime(start + i)); + // only one instance for non-periodic reservation + if (periodicity <= 0) { + Assert.assertEquals(Resource.newInstance(1024 * (alloc[i]), (alloc[i])), + plan.getTotalCommittedResources(start + i)); + Assert.assertEquals(Resource.newInstance(1024 * (alloc[i]), (alloc[i])), + userCons.getCapacityAtTime(start + i)); + } else { + // periodic reservations should repeat + long y = 0; + Resource res = Resource.newInstance(1024 * (alloc[i]), (alloc[i])); + while (y <= end * 2) { + Assert.assertEquals("At time: " + start + i + y, res, + plan.getTotalCommittedResources(start + i + y)); + Assert.assertEquals(" At time: " + (start + i + y), res, + userCons.getCapacityAtTime(start + i + y)); + y = y + periodicity; + } + } } } @Test public void testAddEmptyReservation() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = - ReservationSystemTestUtil.getNewReservationId(); + ReservationSystemTestUtil.getNewReservationId(); int[] alloc = {}; int start = 100; - ReservationAllocation rAllocation = createReservationAllocation - (reservationID, start, alloc); + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -148,15 +202,14 @@ public class TestInMemoryPlan { @Test public void testAddReservationAlreadyExists() { // First add a reservation - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = - ReservationSystemTestUtil.getNewReservationId(); + ReservationSystemTestUtil.getNewReservationId(); int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; - ReservationAllocation rAllocation = createReservationAllocation - (reservationID, start, alloc); + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -164,7 +217,7 @@ public class TestInMemoryPlan { Assert.fail(e.getMessage()); } doAssertions(plan, rAllocation); - checkAllocation(plan, alloc, start); + checkAllocation(plan, alloc, start, 0); // Try to add it again try { @@ -180,16 +233,15 @@ public class TestInMemoryPlan { @Test public void testUpdateReservation() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = ReservationSystemTestUtil.getNewReservationId(); // First add a reservation int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; - ReservationAllocation rAllocation = createReservationAllocation - (reservationID, start, alloc); + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -210,8 +262,8 @@ public class TestInMemoryPlan { // Now update it start = 110; int[] updatedAlloc = { 0, 5, 10, 10, 5, 0 }; - rAllocation = createReservationAllocation(reservationID, start, - updatedAlloc, true); + rAllocation = + createReservationAllocation(reservationID, start, updatedAlloc, true); try { plan.updateReservation(rAllocation); } catch (PlanningException e) { @@ -219,32 +271,71 @@ public class TestInMemoryPlan { } doAssertions(plan, rAllocation); - userCons = - plan.getConsumptionForUserOverTime(user, start, start - + updatedAlloc.length); + userCons = plan.getConsumptionForUserOverTime(user, start, + start + updatedAlloc.length); for (int i = 0; i < updatedAlloc.length; i++) { - Assert.assertEquals( - Resource.newInstance(1024 * (updatedAlloc[i] + i), updatedAlloc[i] - + i), plan.getTotalCommittedResources(start + i)); - Assert.assertEquals( - Resource.newInstance(1024 * (updatedAlloc[i] + i), updatedAlloc[i] - + i), userCons.getCapacityAtTime(start + i)); + Assert.assertEquals(Resource.newInstance(1024 * (updatedAlloc[i] + i), + updatedAlloc[i] + i), plan.getTotalCommittedResources(start + i)); + Assert.assertEquals(Resource.newInstance(1024 * (updatedAlloc[i] + i), + updatedAlloc[i] + i), userCons.getCapacityAtTime(start + i)); + } + } + + @Test + public void testUpdatePeriodicReservation() { + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + // First add a reservation + ReservationId reservationID = + ReservationSystemTestUtil.getNewReservationId(); + int[] alloc = { 10, 20 }; + int start = 100; + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); + // use periodicity of 1hr + long period = 3600000; + rAllocation.getReservationDefinition() + .setRecurrenceExpression(String.valueOf(period)); + rAllocation.setPeriodicity(period); + Assert.assertNull(plan.getReservationById(reservationID)); + try { + plan.addReservation(rAllocation, false); + } catch (PlanningException e) { + Assert.fail(e.getMessage()); + } + System.out.println(plan.toString()); + doAssertions(plan, rAllocation); + checkAllocation(plan, alloc, start, period); + + // Now update it + start = 110; + int[] updatedAlloc = { 30, 40, 50 }; + rAllocation = + createReservationAllocation(reservationID, start, updatedAlloc); + rAllocation.getReservationDefinition() + .setRecurrenceExpression(String.valueOf(period)); + rAllocation.setPeriodicity(period); + try { + plan.updateReservation(rAllocation); + } catch (PlanningException e) { + Assert.fail(e.getMessage()); } + doAssertions(plan, rAllocation); + checkAllocation(plan, updatedAlloc, start, period); } @Test public void testUpdateNonExistingReservation() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = ReservationSystemTestUtil.getNewReservationId(); // Try to update a reservation without adding int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; ReservationAllocation rAllocation = - createReservationAllocation(reservationID, start, alloc); + createReservationAllocation(reservationID, start, alloc); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.updateReservation(rAllocation); @@ -260,15 +351,14 @@ public class TestInMemoryPlan { @Test public void testDeleteReservation() { // First add a reservation - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = ReservationSystemTestUtil.getNewReservationId(); int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; ReservationAllocation rAllocation = - createReservationAllocation(reservationID, start, alloc, true); + createReservationAllocation(reservationID, start, alloc, true); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -307,10 +397,46 @@ public class TestInMemoryPlan { } @Test + public void testDeletePeriodicReservation() { + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + // First add a reservation + ReservationId reservationID = + ReservationSystemTestUtil.getNewReservationId(); + int[] alloc = { 10, 20 }; + int start = 100; + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); + // use periodicity of 1hr + long period = 3600000; + rAllocation.getReservationDefinition() + .setRecurrenceExpression(String.valueOf(period)); + rAllocation.setPeriodicity(period); + Assert.assertNull(plan.getReservationById(reservationID)); + try { + plan.addReservation(rAllocation, false); + } catch (PlanningException e) { + Assert.fail(e.getMessage()); + } + System.out.println(plan.toString()); + doAssertions(plan, rAllocation); + checkAllocation(plan, alloc, start, period); + + // Now delete it + try { + plan.deleteReservation(reservationID); + } catch (PlanningException e) { + Assert.fail(e.getMessage()); + } + Assert.assertNull(plan.getReservationById(reservationID)); + System.out.print(plan); + checkAllocation(plan, new int[] { 0, 0 }, start, period); + } + + @Test public void testDeleteNonExistingReservation() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = ReservationSystemTestUtil.getNewReservationId(); // Try to delete a reservation without adding @@ -328,8 +454,9 @@ public class TestInMemoryPlan { @Test public void testArchiveCompletedReservations() { + SharingPolicy sharingPolicy = mock(SharingPolicy.class); Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + new InMemoryPlan(queueMetrics, sharingPolicy, agent, totalCapacity, 1L, resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID1 = ReservationSystemTestUtil.getNewReservationId(); @@ -337,7 +464,7 @@ public class TestInMemoryPlan { int[] alloc1 = { 10, 10, 10, 10, 10, 10 }; int start = 100; ReservationAllocation rAllocation = - createReservationAllocation(reservationID1, start, alloc1); + createReservationAllocation(reservationID1, start, alloc1); Assert.assertNull(plan.getReservationById(reservationID1)); try { plan.addReservation(rAllocation, false); @@ -345,15 +472,14 @@ public class TestInMemoryPlan { Assert.fail(e.getMessage()); } doAssertions(plan, rAllocation); - checkAllocation(plan, alloc1, start); - + checkAllocation(plan, alloc1, start, 0); // Now add another one ReservationId reservationID2 = ReservationSystemTestUtil.getNewReservationId(); int[] alloc2 = { 0, 5, 10, 5, 0 }; rAllocation = - createReservationAllocation(reservationID2, start, alloc2, true); + createReservationAllocation(reservationID2, start, alloc2, true); Assert.assertNull(plan.getReservationById(reservationID2)); try { plan.addReservation(rAllocation, false); @@ -367,16 +493,18 @@ public class TestInMemoryPlan { for (int i = 0; i < alloc2.length; i++) { Assert.assertEquals( - Resource.newInstance(1024 * (alloc1[i] + alloc2[i] + i), alloc1[i] - + alloc2[i] + i), plan.getTotalCommittedResources(start + i)); + Resource.newInstance(1024 * (alloc1[i] + alloc2[i] + i), + alloc1[i] + alloc2[i] + i), + plan.getTotalCommittedResources(start + i)); Assert.assertEquals( - Resource.newInstance(1024 * (alloc1[i] + alloc2[i] + i), alloc1[i] - + alloc2[i] + i), userCons.getCapacityAtTime(start + i)); + Resource.newInstance(1024 * (alloc1[i] + alloc2[i] + i), + alloc1[i] + alloc2[i] + i), + userCons.getCapacityAtTime(start + i)); } // Now archive completed reservations when(clock.getTime()).thenReturn(106L); - when(policy.getValidWindow()).thenReturn(1L); + when(sharingPolicy.getValidWindow()).thenReturn(1L); try { // will only remove 2nd reservation as only that has fallen out of the // archival window @@ -386,7 +514,7 @@ public class TestInMemoryPlan { } Assert.assertNotNull(plan.getReservationById(reservationID1)); Assert.assertNull(plan.getReservationById(reservationID2)); - checkAllocation(plan, alloc1, start); + checkAllocation(plan, alloc1, start, 0); when(clock.getTime()).thenReturn(107L); try { @@ -411,15 +539,14 @@ public class TestInMemoryPlan { @Test public void testGetReservationsById() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = - ReservationSystemTestUtil.getNewReservationId(); - int[] alloc = {10, 10, 10, 10, 10, 10}; + ReservationSystemTestUtil.getNewReservationId(); + int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; - ReservationAllocation rAllocation = createReservationAllocation - (reservationID, start, alloc); + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -429,31 +556,30 @@ public class TestInMemoryPlan { // Verify that get by reservation id works. Set rAllocations = - plan.getReservations(reservationID, null, ""); + plan.getReservations(reservationID, null, ""); Assert.assertTrue(rAllocations.size() == 1); - Assert.assertTrue(rAllocation.compareTo( - (ReservationAllocation) rAllocations.toArray()[0]) == 0); + Assert.assertTrue(rAllocation + .compareTo((ReservationAllocation) rAllocations.toArray()[0]) == 0); // Verify that get by reservation id works even when time range // and user is invalid. ReservationInterval interval = new ReservationInterval(0, 0); rAllocations = plan.getReservations(reservationID, interval, "invalid"); Assert.assertTrue(rAllocations.size() == 1); - Assert.assertTrue(rAllocation.compareTo( - (ReservationAllocation) rAllocations.toArray()[0]) == 0); + Assert.assertTrue(rAllocation + .compareTo((ReservationAllocation) rAllocations.toArray()[0]) == 0); } @Test public void testGetReservationsByInvalidId() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = - ReservationSystemTestUtil.getNewReservationId(); - int[] alloc = {10, 10, 10, 10, 10, 10}; + ReservationSystemTestUtil.getNewReservationId(); + int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; - ReservationAllocation rAllocation = createReservationAllocation - (reservationID, start, alloc); + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -463,23 +589,22 @@ public class TestInMemoryPlan { // If reservationId is null, then nothing is returned. ReservationId invalidReservationID = - ReservationSystemTestUtil.getNewReservationId(); + ReservationSystemTestUtil.getNewReservationId(); Set rAllocations = - plan.getReservations(invalidReservationID, null, ""); + plan.getReservations(invalidReservationID, null, ""); Assert.assertTrue(rAllocations.size() == 0); } @Test public void testGetReservationsByTimeInterval() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = - ReservationSystemTestUtil.getNewReservationId(); - int[] alloc = {10, 10, 10, 10, 10, 10}; + ReservationSystemTestUtil.getNewReservationId(); + int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; - ReservationAllocation rAllocation = createReservationAllocation - (reservationID, start, alloc); + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -489,23 +614,24 @@ public class TestInMemoryPlan { // Verify that get by time interval works if the selection interval // completely overlaps with the allocation. - ReservationInterval interval = new ReservationInterval(rAllocation - .getStartTime(), rAllocation.getEndTime()); + ReservationInterval interval = new ReservationInterval( + rAllocation.getStartTime(), rAllocation.getEndTime()); Set rAllocations = - plan.getReservations(null, interval, ""); + plan.getReservations(null, interval, ""); Assert.assertTrue(rAllocations.size() == 1); - Assert.assertTrue(rAllocation.compareTo( - (ReservationAllocation) rAllocations.toArray()[0]) == 0); + Assert.assertTrue(rAllocation + .compareTo((ReservationAllocation) rAllocations.toArray()[0]) == 0); // Verify that get by time interval works if the selection interval // falls within the allocation long duration = rAllocation.getEndTime() - rAllocation.getStartTime(); - interval = new ReservationInterval(rAllocation.getStartTime() + duration - * (long)0.3, rAllocation.getEndTime() - duration * (long)0.3); + interval = new ReservationInterval( + rAllocation.getStartTime() + duration * (long) 0.3, + rAllocation.getEndTime() - duration * (long) 0.3); rAllocations = plan.getReservations(null, interval, ""); Assert.assertTrue(rAllocations.size() == 1); - Assert.assertTrue(rAllocation.compareTo( - (ReservationAllocation) rAllocations.toArray()[0]) == 0); + Assert.assertTrue(rAllocation + .compareTo((ReservationAllocation) rAllocations.toArray()[0]) == 0); // Verify that get by time interval selects 1 allocation if the end // time of the selection interval falls right at the start of the @@ -513,13 +639,13 @@ public class TestInMemoryPlan { interval = new ReservationInterval(0, rAllocation.getStartTime()); rAllocations = plan.getReservations(null, interval, ""); Assert.assertTrue(rAllocations.size() == 1); - Assert.assertTrue(rAllocation.compareTo( - (ReservationAllocation) rAllocations.toArray()[0]) == 0); + Assert.assertTrue(rAllocation + .compareTo((ReservationAllocation) rAllocations.toArray()[0]) == 0); // Verify that get by time interval selects no reservations if the start // time of the selection interval falls right at the end of the allocation. - interval = new ReservationInterval(rAllocation - .getEndTime(), Long.MAX_VALUE); + interval = + new ReservationInterval(rAllocation.getEndTime(), Long.MAX_VALUE); rAllocations = plan.getReservations(null, interval, ""); Assert.assertTrue(rAllocations.size() == 0); @@ -532,15 +658,14 @@ public class TestInMemoryPlan { @Test public void testGetReservationsAtTime() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = - ReservationSystemTestUtil.getNewReservationId(); - int[] alloc = {10, 10, 10, 10, 10, 10}; + ReservationSystemTestUtil.getNewReservationId(); + int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; - ReservationAllocation rAllocation = createReservationAllocation - (reservationID, start, alloc); + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -549,23 +674,22 @@ public class TestInMemoryPlan { } Set rAllocations = - plan.getReservationsAtTime(rAllocation.getStartTime()); + plan.getReservationsAtTime(rAllocation.getStartTime()); Assert.assertTrue(rAllocations.size() == 1); - Assert.assertTrue(rAllocation.compareTo( - (ReservationAllocation) rAllocations.toArray()[0]) == 0); + Assert.assertTrue(rAllocation + .compareTo((ReservationAllocation) rAllocations.toArray()[0]) == 0); } @Test public void testGetReservationsWithNoInput() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); ReservationId reservationID = - ReservationSystemTestUtil.getNewReservationId(); - int[] alloc = {10, 10, 10, 10, 10, 10}; + ReservationSystemTestUtil.getNewReservationId(); + int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; - ReservationAllocation rAllocation = createReservationAllocation - (reservationID, start, alloc); + ReservationAllocation rAllocation = + createReservationAllocation(reservationID, start, alloc); Assert.assertNull(plan.getReservationById(reservationID)); try { plan.addReservation(rAllocation, false); @@ -576,22 +700,21 @@ public class TestInMemoryPlan { // Verify that getReservations defaults to getting all reservations if no // reservationID, time interval, and user is provided, Set rAllocations = - plan.getReservations(null, null, ""); + plan.getReservations(null, null, ""); Assert.assertTrue(rAllocations.size() == 1); - Assert.assertTrue(rAllocation.compareTo( - (ReservationAllocation) rAllocations.toArray()[0]) == 0); + Assert.assertTrue(rAllocation + .compareTo((ReservationAllocation) rAllocations.toArray()[0]) == 0); } @Test public void testGetReservationsWithNoReservation() { - Plan plan = - new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, - resCalc, minAlloc, maxAlloc, planName, replanner, true, context); + Plan plan = new InMemoryPlan(queueMetrics, policy, agent, totalCapacity, 1L, + resCalc, minAlloc, maxAlloc, planName, replanner, true, context); // Verify that get reservation returns no entries if no queries are made. ReservationInterval interval = new ReservationInterval(0, Long.MAX_VALUE); Set rAllocations = - plan.getReservations(null, interval, ""); + plan.getReservations(null, interval, ""); Assert.assertTrue(rAllocations.size() == 0); } @@ -600,7 +723,9 @@ public class TestInMemoryPlan { Assert.assertNotNull(plan.getReservationById(reservationID)); Assert.assertEquals(rAllocation, plan.getReservationById(reservationID)); Assert.assertTrue(((InMemoryPlan) plan).getAllReservations().size() == 1); - Assert.assertEquals(rAllocation.getEndTime(), plan.getLastEndTime()); + if (rAllocation.getPeriodicity() <= 0) { + Assert.assertEquals(rAllocation.getEndTime(), plan.getLastEndTime()); + } Assert.assertEquals(totalCapacity, plan.getTotalCapacity()); Assert.assertEquals(minAlloc, plan.getMinimumAllocation()); Assert.assertEquals(maxAlloc, plan.getMaximumAllocation()); @@ -610,7 +735,8 @@ public class TestInMemoryPlan { } private ReservationDefinition createSimpleReservationDefinition(long arrival, - long deadline, long duration, Collection resources) { + long deadline, long duration, Collection resources, + String recurrenceExpression) { // create a request with a single atomic ask ReservationDefinition rDef = new ReservationDefinitionPBImpl(); ReservationRequests reqs = new ReservationRequestsPBImpl(); @@ -619,6 +745,7 @@ public class TestInMemoryPlan { rDef.setReservationRequests(reqs); rDef.setArrival(arrival); rDef.setDeadline(deadline); + rDef.setRecurrenceExpression(recurrenceExpression); return rDef; } @@ -633,31 +760,43 @@ public class TestInMemoryPlan { } else { numContainers = alloc[i]; } - ReservationRequest rr = - ReservationRequest.newInstance(Resource.newInstance(1024, 1), - (numContainers)); + ReservationRequest rr = ReservationRequest + .newInstance(Resource.newInstance(1024, 1), (numContainers)); req.put(new ReservationInterval(startTime + i, startTime + i + 1), rr); } return req; } - private ReservationAllocation createReservationAllocation(ReservationId - reservationID, int start, int[] alloc) { - return createReservationAllocation(reservationID, start, alloc, false); + private ReservationAllocation createReservationAllocation( + ReservationId reservationID, int start, int[] alloc) { + return createReservationAllocation(reservationID, start, alloc, false, "0"); + } + + private ReservationAllocation createReservationAllocation( + ReservationId reservationID, int start, int[] alloc, boolean isStep) { + return createReservationAllocation(reservationID, start, alloc, isStep, + "0"); + } + + private ReservationAllocation createReservationAllocation( + ReservationId reservationID, int start, int[] alloc, + String recurrenceExp) { + return createReservationAllocation(reservationID, start, alloc, false, + recurrenceExp); } - private ReservationAllocation createReservationAllocation(ReservationId - reservationID, int start, int[] alloc, boolean isStep) { + private ReservationAllocation createReservationAllocation( + ReservationId reservationID, int start, int[] alloc, boolean isStep, + String recurrenceExp) { Map allocations = - generateAllocation(start, alloc, isStep); + generateAllocation(start, alloc, isStep); ReservationDefinition rDef = - createSimpleReservationDefinition(start, start + alloc.length, - alloc.length, allocations.values()); + createSimpleReservationDefinition(start, start + alloc.length, + alloc.length, allocations.values(), recurrenceExp); Map allocs = - ReservationSystemUtil.toResources(allocations); + ReservationSystemUtil.toResources(allocations); return new InMemoryReservationAllocation(reservationID, rDef, user, - planName, - start, start + alloc.length, allocs, resCalc, minAlloc); + planName, start, start + alloc.length, allocs, resCalc, minAlloc); } } http://git-wip-us.apache.org/repos/asf/hadoop/blob/b6e7d136/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestPeriodicRLESparseResourceAllocation.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestPeriodicRLESparseResourceAllocation.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestPeriodicRLESparseResourceAllocation.java index 554eb58..457e2ee 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestPeriodicRLESparseResourceAllocation.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestPeriodicRLESparseResourceAllocation.java @@ -19,26 +19,27 @@ package org.apache.hadoop.yarn.server.resourcemanager.reservation; import org.apache.hadoop.yarn.api.records.Resource; +import org.apache.hadoop.yarn.server.resourcemanager.reservation.exceptions.PlanningException; import org.junit.Assert; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** - * Testing the class PeriodicRLESparseResourceAllocation. + * Testing the class {@link PeriodicRLESparseResourceAllocation}. */ +@SuppressWarnings("checkstyle:nowhitespaceafter") public class TestPeriodicRLESparseResourceAllocation { - private static final Logger LOG = LoggerFactory - .getLogger(TestPeriodicRLESparseResourceAllocation.class); + private static final Logger LOG = + LoggerFactory.getLogger(TestPeriodicRLESparseResourceAllocation.class); @Test public void testPeriodicCapacity() { - int[] alloc = {10, 7, 5, 2, 0}; - long[] timeSteps = {0L, 5L, 10L, 15L, 19L}; - RLESparseResourceAllocation rleSparseVector = - ReservationSystemTestUtil.generateRLESparseResourceAllocation( - alloc, timeSteps); + int[] alloc = { 10, 7, 5, 2, 0 }; + long[] timeSteps = { 0L, 5L, 10L, 15L, 19L }; + RLESparseResourceAllocation rleSparseVector = ReservationSystemTestUtil + .generateRLESparseResourceAllocation(alloc, timeSteps); PeriodicRLESparseResourceAllocation periodicVector = new PeriodicRLESparseResourceAllocation(rleSparseVector, 20L); LOG.info(periodicVector.toString()); @@ -54,43 +55,74 @@ public class TestPeriodicRLESparseResourceAllocation { @Test public void testMaxPeriodicCapacity() { - int[] alloc = {2, 5, 7, 10, 3, 4, 6, 8}; - long[] timeSteps = {0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L}; - RLESparseResourceAllocation rleSparseVector = - ReservationSystemTestUtil.generateRLESparseResourceAllocation( - alloc, timeSteps); + int[] alloc = { 2, 5, 7, 10, 3, 4, 6, 8 }; + long[] timeSteps = { 0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L }; + RLESparseResourceAllocation rleSparseVector = ReservationSystemTestUtil + .generateRLESparseResourceAllocation(alloc, timeSteps); PeriodicRLESparseResourceAllocation periodicVector = new PeriodicRLESparseResourceAllocation(rleSparseVector, 8L); LOG.info(periodicVector.toString()); - Assert.assertEquals( - periodicVector.getMaximumPeriodicCapacity(0, 1), + Assert.assertEquals(periodicVector.getMaximumPeriodicCapacity(0, 1), Resource.newInstance(10, 10)); - Assert.assertEquals( - periodicVector.getMaximumPeriodicCapacity(8, 2), + Assert.assertEquals(periodicVector.getMaximumPeriodicCapacity(8, 2), Resource.newInstance(7, 7)); - Assert.assertEquals( - periodicVector.getMaximumPeriodicCapacity(16, 3), + Assert.assertEquals(periodicVector.getMaximumPeriodicCapacity(16, 3), Resource.newInstance(10, 10)); - Assert.assertEquals( - periodicVector.getMaximumPeriodicCapacity(17, 4), + Assert.assertEquals(periodicVector.getMaximumPeriodicCapacity(17, 4), Resource.newInstance(5, 5)); - Assert.assertEquals( - periodicVector.getMaximumPeriodicCapacity(32, 5), + Assert.assertEquals(periodicVector.getMaximumPeriodicCapacity(32, 5), Resource.newInstance(4, 4)); } @Test + public void testMixPeriodicAndNonPeriodic() throws PlanningException { + int[] alloc = { 2, 5, 0 }; + long[] timeSteps = { 1L, 2L, 3L }; + RLESparseResourceAllocation tempPeriodic = ReservationSystemTestUtil + .generateRLESparseResourceAllocation(alloc, timeSteps); + PeriodicRLESparseResourceAllocation periodic = + new PeriodicRLESparseResourceAllocation(tempPeriodic, 10L); + + int[] alloc2 = { 10, 10, 0 }; + long[] timeSteps2 = { 12L, 13L, 14L }; + RLESparseResourceAllocation nonPeriodic = ReservationSystemTestUtil + .generateRLESparseResourceAllocation(alloc2, timeSteps2); + + RLESparseResourceAllocation merged = + RLESparseResourceAllocation.merge(nonPeriodic.getResourceCalculator(), + Resource.newInstance(100 * 1024, 100), periodic, nonPeriodic, + RLESparseResourceAllocation.RLEOperator.add, 2, 25); + + Assert.assertEquals(Resource.newInstance(5, 5), + merged.getCapacityAtTime(2L)); + Assert.assertEquals(Resource.newInstance(0, 0), + merged.getCapacityAtTime(3L)); + Assert.assertEquals(Resource.newInstance(2, 2), + merged.getCapacityAtTime(11L)); + Assert.assertEquals(Resource.newInstance(15, 15), + merged.getCapacityAtTime(12L)); + Assert.assertEquals(Resource.newInstance(10, 10), + merged.getCapacityAtTime(13L)); + Assert.assertEquals(Resource.newInstance(0, 0), + merged.getCapacityAtTime(14L)); + Assert.assertEquals(Resource.newInstance(2, 2), + merged.getCapacityAtTime(21L)); + Assert.assertEquals(Resource.newInstance(5, 5), + merged.getCapacityAtTime(22L)); + Assert.assertEquals(Resource.newInstance(0, 0), + merged.getCapacityAtTime(23L)); + } + + @Test public void testSetCapacityInInterval() { - int[] alloc = {2, 5, 0}; - long[] timeSteps = {1L, 2L, 3L}; - RLESparseResourceAllocation rleSparseVector = - ReservationSystemTestUtil.generateRLESparseResourceAllocation( - alloc, timeSteps); + int[] alloc = { 2, 5, 0 }; + long[] timeSteps = { 1L, 2L, 3L }; + RLESparseResourceAllocation rleSparseVector = ReservationSystemTestUtil + .generateRLESparseResourceAllocation(alloc, timeSteps); PeriodicRLESparseResourceAllocation periodicVector = new PeriodicRLESparseResourceAllocation(rleSparseVector, 10L); ReservationInterval interval = new ReservationInterval(5L, 10L); - periodicVector.addInterval( - interval, Resource.newInstance(8, 8)); + periodicVector.addInterval(interval, Resource.newInstance(8, 8)); Assert.assertEquals(Resource.newInstance(8, 8), periodicVector.getCapacityAtTime(5L)); Assert.assertEquals(Resource.newInstance(8, 8), @@ -99,21 +131,20 @@ public class TestPeriodicRLESparseResourceAllocation { periodicVector.getCapacityAtTime(10L)); Assert.assertEquals(Resource.newInstance(0, 0), periodicVector.getCapacityAtTime(0L)); - Assert.assertFalse(periodicVector.addInterval( - new ReservationInterval(7L, 12L), Resource.newInstance(8, 8))); + // Assert.assertFalse(periodicVector.addInterval( + // new ReservationInterval(7L, 12L), Resource.newInstance(8, 8))); } public void testRemoveInterval() { - int[] alloc = {2, 5, 3, 4, 0}; - long[] timeSteps = {1L, 3L, 5L, 7L, 9L}; - RLESparseResourceAllocation rleSparseVector = - ReservationSystemTestUtil.generateRLESparseResourceAllocation( - alloc, timeSteps); + int[] alloc = { 2, 5, 3, 4, 0 }; + long[] timeSteps = { 1L, 3L, 5L, 7L, 9L }; + RLESparseResourceAllocation rleSparseVector = ReservationSystemTestUtil + .generateRLESparseResourceAllocation(alloc, timeSteps); PeriodicRLESparseResourceAllocation periodicVector = new PeriodicRLESparseResourceAllocation(rleSparseVector, 10L); ReservationInterval interval = new ReservationInterval(3L, 7L); - Assert.assertTrue(periodicVector.removeInterval( - interval, Resource.newInstance(3, 3))); + Assert.assertTrue( + periodicVector.removeInterval(interval, Resource.newInstance(3, 3))); Assert.assertEquals(Resource.newInstance(2, 2), periodicVector.getCapacityAtTime(1L)); Assert.assertEquals(Resource.newInstance(2, 2), http://git-wip-us.apache.org/repos/asf/hadoop/blob/b6e7d136/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestRLESparseResourceAllocation.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestRLESparseResourceAllocation.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestRLESparseResourceAllocation.java index bfe46e1..0027ceb 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestRLESparseResourceAllocation.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/TestRLESparseResourceAllocation.java @@ -40,10 +40,14 @@ import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +/** + * Testing the class {@link RLESparseResourceAllocation}. + */ +@SuppressWarnings("checkstyle:nowhitespaceafter") public class TestRLESparseResourceAllocation { - private static final Logger LOG = LoggerFactory - .getLogger(TestRLESparseResourceAllocation.class); + private static final Logger LOG = + LoggerFactory.getLogger(TestRLESparseResourceAllocation.class); @Test public void testMergeAdd() throws PlanningException { @@ -196,7 +200,8 @@ public class TestRLESparseResourceAllocation { // Expected! } - // Testing that the subtractTestNonNegative detects problems even if only one + // Testing that the subtractTestNonNegative detects problems even if only + // one // of the resource dimensions is "<0" a.put(10L, Resource.newInstance(10, 5)); b.put(11L, Resource.newInstance(5, 6)); @@ -286,9 +291,8 @@ public class TestRLESparseResourceAllocation { public void testRangeOverlapping() { ResourceCalculator resCalc = new DefaultResourceCalculator(); - RLESparseResourceAllocation r = - new RLESparseResourceAllocation(resCalc); - int[] alloc = {10, 10, 10, 10, 10, 10}; + RLESparseResourceAllocation r = new RLESparseResourceAllocation(resCalc); + int[] alloc = { 10, 10, 10, 10, 10, 10 }; int start = 100; Set> inputs = generateAllocation(start, alloc, false).entrySet(); @@ -299,9 +303,9 @@ public class TestRLESparseResourceAllocation { long d = r.getLatestNonNullTime(); // tries to trigger "out-of-range" bug - r = r.getRangeOverlapping(s, d); - r = r.getRangeOverlapping(s-1, d-1); - r = r.getRangeOverlapping(s+1, d+1); + r = r.getRangeOverlapping(s, d); + r = r.getRangeOverlapping(s - 1, d - 1); + r = r.getRangeOverlapping(s + 1, d + 1); } @Test @@ -370,25 +374,29 @@ public class TestRLESparseResourceAllocation { // Current bug prevents this to pass. The RLESparseResourceAllocation // does not handle removal of "partial" // allocations correctly. - Assert.assertEquals(102400, rleSparseVector.getCapacityAtTime(10) - .getMemorySize()); - Assert.assertEquals(0, rleSparseVector.getCapacityAtTime(13).getMemorySize()); - Assert.assertEquals(0, rleSparseVector.getCapacityAtTime(19).getMemorySize()); - Assert.assertEquals(102400, rleSparseVector.getCapacityAtTime(21) - .getMemorySize()); - Assert.assertEquals(2 * 102400, rleSparseVector.getCapacityAtTime(26) - .getMemorySize()); + Assert.assertEquals(102400, + rleSparseVector.getCapacityAtTime(10).getMemorySize()); + Assert.assertEquals(0, + rleSparseVector.getCapacityAtTime(13).getMemorySize()); + Assert.assertEquals(0, + rleSparseVector.getCapacityAtTime(19).getMemorySize()); + Assert.assertEquals(102400, + rleSparseVector.getCapacityAtTime(21).getMemorySize()); + Assert.assertEquals(2 * 102400, + rleSparseVector.getCapacityAtTime(26).getMemorySize()); ReservationInterval riRemove2 = new ReservationInterval(9, 13); rleSparseVector.removeInterval(riRemove2, rr); LOG.info(rleSparseVector.toString()); - Assert.assertEquals(0, rleSparseVector.getCapacityAtTime(11).getMemorySize()); - Assert.assertEquals(-102400, rleSparseVector.getCapacityAtTime(9) - .getMemorySize()); - Assert.assertEquals(0, rleSparseVector.getCapacityAtTime(13).getMemorySize()); - Assert.assertEquals(102400, rleSparseVector.getCapacityAtTime(20) - .getMemorySize()); + Assert.assertEquals(0, + rleSparseVector.getCapacityAtTime(11).getMemorySize()); + Assert.assertEquals(-102400, + rleSparseVector.getCapacityAtTime(9).getMemorySize()); + Assert.assertEquals(0, + rleSparseVector.getCapacityAtTime(13).getMemorySize()); + Assert.assertEquals(102400, + rleSparseVector.getCapacityAtTime(20).getMemorySize()); } @@ -500,7 +508,8 @@ public class TestRLESparseResourceAllocation { } mapAllocations = rleSparseVector.toIntervalMap(); Assert.assertTrue(mapAllocations.size() == 5); - for (Entry entry : mapAllocations.entrySet()) { + for (Entry entry : mapAllocations + .entrySet()) { ReservationInterval interval = entry.getKey(); Resource resource = entry.getValue(); if (interval.getStartTime() == 101L) { @@ -526,59 +535,46 @@ public class TestRLESparseResourceAllocation { @Test public void testMaxPeriodicCapacity() { - long[] timeSteps = {0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L}; - int[] alloc = {2, 5, 7, 10, 3, 4, 6, 8}; - RLESparseResourceAllocation rleSparseVector = - ReservationSystemTestUtil.generateRLESparseResourceAllocation( - alloc, timeSteps); + long[] timeSteps = { 0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L }; + int[] alloc = { 2, 5, 7, 10, 3, 4, 6, 8 }; + RLESparseResourceAllocation rleSparseVector = ReservationSystemTestUtil + .generateRLESparseResourceAllocation(alloc, timeSteps); LOG.info(rleSparseVector.toString()); - Assert.assertEquals( - rleSparseVector.getMaximumPeriodicCapacity(0, 1), + Assert.assertEquals(rleSparseVector.getMaximumPeriodicCapacity(0, 1), Resource.newInstance(10, 10)); - Assert.assertEquals( - rleSparseVector.getMaximumPeriodicCapacity(0, 2), + Assert.assertEquals(rleSparseVector.getMaximumPeriodicCapacity(0, 2), Resource.newInstance(7, 7)); - Assert.assertEquals( - rleSparseVector.getMaximumPeriodicCapacity(0, 3), + Assert.assertEquals(rleSparseVector.getMaximumPeriodicCapacity(0, 3), Resource.newInstance(10, 10)); - Assert.assertEquals( - rleSparseVector.getMaximumPeriodicCapacity(0, 4), + Assert.assertEquals(rleSparseVector.getMaximumPeriodicCapacity(0, 4), Resource.newInstance(3, 3)); - Assert.assertEquals( - rleSparseVector.getMaximumPeriodicCapacity(0, 5), + Assert.assertEquals(rleSparseVector.getMaximumPeriodicCapacity(0, 5), Resource.newInstance(4, 4)); - Assert.assertEquals( - rleSparseVector.getMaximumPeriodicCapacity(0, 5), + Assert.assertEquals(rleSparseVector.getMaximumPeriodicCapacity(0, 5), Resource.newInstance(4, 4)); - Assert.assertEquals( - rleSparseVector.getMaximumPeriodicCapacity(7, 5), + Assert.assertEquals(rleSparseVector.getMaximumPeriodicCapacity(7, 5), Resource.newInstance(8, 8)); - Assert.assertEquals( - rleSparseVector.getMaximumPeriodicCapacity(10, 3), + Assert.assertEquals(rleSparseVector.getMaximumPeriodicCapacity(10, 3), Resource.newInstance(0, 0)); } @Test public void testGetMinimumCapacityInInterval() { - long[] timeSteps = {0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L}; - int[] alloc = {2, 5, 7, 10, 3, 4, 0, 8}; - RLESparseResourceAllocation rleSparseVector = - ReservationSystemTestUtil.generateRLESparseResourceAllocation( - alloc, timeSteps); + long[] timeSteps = { 0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L }; + int[] alloc = { 2, 5, 7, 10, 3, 4, 0, 8 }; + RLESparseResourceAllocation rleSparseVector = ReservationSystemTestUtil + .generateRLESparseResourceAllocation(alloc, timeSteps); LOG.info(rleSparseVector.toString()); - Assert.assertEquals( - rleSparseVector.getMinimumCapacityInInterval( - new ReservationInterval(1L, 3L)), Resource.newInstance(5, 5)); - Assert.assertEquals( - rleSparseVector.getMinimumCapacityInInterval( - new ReservationInterval(2L, 5L)), Resource.newInstance(3, 3)); - Assert.assertEquals( - rleSparseVector.getMinimumCapacityInInterval( - new ReservationInterval(1L, 7L)), Resource.newInstance(0, 0)); + Assert.assertEquals(rleSparseVector.getMinimumCapacityInInterval( + new ReservationInterval(1L, 3L)), Resource.newInstance(5, 5)); + Assert.assertEquals(rleSparseVector.getMinimumCapacityInInterval( + new ReservationInterval(2L, 5L)), Resource.newInstance(3, 3)); + Assert.assertEquals(rleSparseVector.getMinimumCapacityInInterval( + new ReservationInterval(1L, 7L)), Resource.newInstance(0, 0)); } - private void setupArrays( - TreeMap a, TreeMap b) { + private void setupArrays(TreeMap a, + TreeMap b) { a.put(10L, Resource.newInstance(5, 5)); a.put(20L, Resource.newInstance(10, 10)); a.put(30L, Resource.newInstance(15, 15)); @@ -620,8 +616,8 @@ public class TestRLESparseResourceAllocation { numContainers = alloc[i]; } req.put(new ReservationInterval(startTime + i, startTime + i + 1), - ReservationSystemUtil.toResource(ReservationRequest.newInstance( - Resource.newInstance(1024, 1), (numContainers)))); + ReservationSystemUtil.toResource(ReservationRequest + .newInstance(Resource.newInstance(1024, 1), (numContainers)))); } return req; } http://git-wip-us.apache.org/repos/asf/hadoop/blob/b6e7d136/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/planning/TestSimpleCapacityReplanner.java ---------------------------------------------------------------------- diff --git a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/planning/TestSimpleCapacityReplanner.java b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/planning/TestSimpleCapacityReplanner.java index c4f94c2..ddd290d 100644 --- a/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/planning/TestSimpleCapacityReplanner.java +++ b/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/reservation/planning/TestSimpleCapacityReplanner.java @@ -31,6 +31,7 @@ import org.apache.hadoop.yarn.api.records.ReservationDefinition; import org.apache.hadoop.yarn.api.records.ReservationId; import org.apache.hadoop.yarn.api.records.ReservationRequest; import org.apache.hadoop.yarn.api.records.Resource; +import org.apache.hadoop.yarn.conf.YarnConfiguration; import org.apache.hadoop.yarn.server.resourcemanager.RMContext; import org.apache.hadoop.yarn.server.resourcemanager.reservation.InMemoryPlan; import org.apache.hadoop.yarn.server.resourcemanager.reservation.InMemoryReservationAllocation; @@ -78,9 +79,10 @@ public class TestSimpleCapacityReplanner { enf.init("blah", conf); // Initialize the plan with more resources - InMemoryPlan plan = - new InMemoryPlan(queueMetrics, policy, agent, clusterCapacity, step, - res, minAlloc, maxAlloc, "dedicated", enf, true, context, clock); + InMemoryPlan plan = new InMemoryPlan(queueMetrics, policy, agent, + clusterCapacity, step, res, minAlloc, maxAlloc, "dedicated", enf, true, + YarnConfiguration.DEFAULT_RM_RESERVATION_SYSTEM_MAX_PERIODICITY, + context, clock); // add reservation filling the plan (separating them 1ms, so we are sure // s2 follows s1 on acceptance --------------------------------------------------------------------- To unsubscribe, e-mail: common-commits-unsubscribe@hadoop.apache.org For additional commands, e-mail: common-commits-help@hadoop.apache.org