YARN-5473. Expose per-application over-allocation info in the Resource Manager. Contributed by Haibo Chen.

hadoop-mapreduce-project/hadoop-mapreduce-client/hadoop-mapreduce-client-common/src/main/java/org/apache/hadoop/mapreduce/TypeConverter.java

@@ -527,8 +527,8 @@ public class TypeConverter {
       jobStatus.setNumUsedSlots(resourceUsageReport.getNumUsedContainers());
       jobStatus.setReservedMem(
           (int)resourceUsageReport.getReservedResources().getMemorySize());
-      jobStatus.setUsedMem(
-          (int) resourceUsageReport.getUsedResources().getMemorySize());
+      jobStatus.setUsedMem((int) resourceUsageReport
+          .getGuaranteedResourcesUsed().getMemorySize());
     }
     return jobStatus;
   }

hadoop-mapreduce-project/hadoop-mapreduce-client/hadoop-mapreduce-client-common/src/test/java/org/apache/hadoop/mapreduce/TestTypeConverter.java

@@ -94,7 +94,7 @@ public class TestTypeConverter {
     appUsageRpt.setNumReservedContainers(1);
     appUsageRpt.setNumUsedContainers(3);
     appUsageRpt.setReservedResources(r);
-    appUsageRpt.setUsedResources(r);
+    appUsageRpt.setGuaranteedResourcesUsed(r);
     applicationReport.setApplicationResourceUsageReport(appUsageRpt);
     JobStatus jobStatus = TypeConverter.fromYarn(applicationReport, "dummy-jobfile");
     Assert.assertEquals(appStartTime, jobStatus.getStartTime());
@@ -133,7 +133,7 @@ public class TestTypeConverter {
     appUsageRpt.setNumReservedContainers(1);
     appUsageRpt.setNumUsedContainers(3);
     appUsageRpt.setReservedResources(r);
-    appUsageRpt.setUsedResources(r);
+    appUsageRpt.setGuaranteedResourcesUsed(r);
     when(mockReport.getApplicationResourceUsageReport()).thenReturn(appUsageRpt);
     JobStatus status = TypeConverter.fromYarn(mockReport, jobFile);
     Assert.assertNotNull("fromYarn returned null status", status);

hadoop-mapreduce-project/hadoop-mapreduce-client/hadoop-mapreduce-client-jobclient/src/test/java/org/apache/hadoop/mapred/TestResourceMgrDelegate.java

@@ -137,7 +137,7 @@ public class TestResourceMgrDelegate {
         Records.newRecord(Resource.class));
     Mockito.when(appResources.getReservedResources()).thenReturn(
         Records.newRecord(Resource.class));
-    Mockito.when(appResources.getUsedResources()).thenReturn(
+    Mockito.when(appResources.getGuaranteedResourcesUsed()).thenReturn(
         Records.newRecord(Resource.class));
     Mockito.when(appReport.getApplicationResourceUsageReport()).thenReturn(
         appResources);

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/java/org/apache/hadoop/yarn/api/records/ApplicationResourceUsageReport.java

@@ -36,21 +36,27 @@ public abstract class ApplicationResourceUsageReport {
   @Private
   @Unstable
   public static ApplicationResourceUsageReport newInstance(
-      int numUsedContainers, int numReservedContainers, Resource usedResources,
+      int numUsedContainers, int numReservedContainers,
+      Resource guaranteedResourcesUsed,
       Resource reservedResources, Resource neededResources,
-      Map<String, Long> resourceSecondsMap, float queueUsagePerc,
-      float clusterUsagePerc, Map<String, Long> preemtedResourceSecondsMap) {
+      Map<String, Long> guaranteedResourceSecondsMap, float queueUsagePerc,
+      float clusterUsagePerc, Map<String, Long> preemtedResourceSecondsMap,
+      Resource opportunisticResourcesUsed,
+      Map<String, Long> opportunisticResourcesSecondsMap) {
+
     ApplicationResourceUsageReport report =
         Records.newRecord(ApplicationResourceUsageReport.class);
     report.setNumUsedContainers(numUsedContainers);
     report.setNumReservedContainers(numReservedContainers);
-    report.setUsedResources(usedResources);
+    report.setGuaranteedResourcesUsed(guaranteedResourcesUsed);
     report.setReservedResources(reservedResources);
     report.setNeededResources(neededResources);
-    report.setResourceSecondsMap(resourceSecondsMap);
+    report.setGuaranteedResourceSecondsMap(guaranteedResourceSecondsMap);
     report.setQueueUsagePercentage(queueUsagePerc);
     report.setClusterUsagePercentage(clusterUsagePerc);
     report.setPreemptedResourceSecondsMap(preemtedResourceSecondsMap);
+    report.setOpportunisticResourcesUsed(opportunisticResourcesUsed);
+    report.setOpportunisticResourceSecondsMap(opportunisticResourcesSecondsMap);
     return report;
   }
 
@@ -87,16 +93,40 @@ public abstract class ApplicationResourceUsageReport {
   public abstract void setNumReservedContainers(int num_reserved_containers);
 
   /**
-   * Get the used <code>Resource</code>.  -1 for invalid/inaccessible reports.
-   * @return the used <code>Resource</code>
+   * Get the guaranteed <code>Resource</code> used.
+   * -1 for invalid/inaccessible reports.
+   * @return the guaranteed <code>Resource</code> used
    */
   @Public
   @Stable
+  @Deprecated
   public abstract Resource getUsedResources();
 
+  /**
+   * Get the guaranteed <code>Resource</code> used.
+   * -1 for invalid/inaccessible reports.
+   * @return the guaranteed <code>Resource</code> used
+   */
+  @Public
+  @Unstable
+  public abstract Resource getGuaranteedResourcesUsed();
+
+  @Private
+  @Unstable
+  public abstract void setGuaranteedResourcesUsed(Resource resources);
+
+  /**
+   * Get the opportunistic <code>Resource</code> used.
+   * -1 for invalid/inaccessible reports.
+   * @return the opportunistic <code>Resource</code> used
+   */
+  @Public
+  @Unstable
+  public abstract Resource getOpportunisticResourcesUsed();
+
   @Private
   @Unstable
-  public abstract void setUsedResources(Resource resources);
+  public abstract void setOpportunisticResourcesUsed(Resource resources);
 
   /**
    * Get the reserved <code>Resource</code>.  -1 for invalid/inaccessible reports.
@@ -123,41 +153,83 @@ public abstract class ApplicationResourceUsageReport {
   public abstract void setNeededResources(Resource needed_resources);
 
   /**
-   * Set the aggregated amount of memory (in megabytes) the application has
-   * allocated times the number of seconds the application has been running.
-   * @param memory_seconds the aggregated amount of memory seconds
+   * Set the aggregated amount of guaranteed memory (in megabytes) the
+   * application has allocated times the number of seconds the application
+   * has been running.
+   * @param memorySeconds the aggregated amount of guaranteed memory seconds
    */
   @Private
   @Unstable
-  public abstract void setMemorySeconds(long memory_seconds);
+  public abstract void setGuaranteedMemorySeconds(long memorySeconds);
 
   /**
-   * Get the aggregated amount of memory (in megabytes) the application has
-   * allocated times the number of seconds the application has been running.
-   * @return the aggregated amount of memory seconds
+   * Get the aggregated amount of guaranteed memory (in megabytes) the
+   * application has allocated times the number of seconds the application
+   * has been running.
+   * @return the aggregated amount of guaranteed memory seconds
+   */
+  @Public
+  @Unstable
+  public abstract long getGuaranteedMemorySeconds();
+
+  /**
+   * Get the aggregated amount of guaranteed memory (in megabytes) the
+   * application has allocated times the number of seconds the application
+   * has been running.
+   * @return the aggregated amount of guaranteed memory seconds
    */
   @Public
   @Unstable
+  @Deprecated
   public abstract long getMemorySeconds();
 
   /**
-   * Set the aggregated number of vcores that the application has allocated
-   * times the number of seconds the application has been running.
-   * @param vcore_seconds the aggregated number of vcore seconds
+   * Set the aggregated number of guaranteed vcores that the application has
+   * allocated times the number of seconds the application has been running.
+   * @param vcoreSeconds the aggregated number of guaranteed vcore seconds
    */
   @Private
   @Unstable
-  public abstract void setVcoreSeconds(long vcore_seconds);
+  public abstract void setGuaranteedVcoreSeconds(long vcoreSeconds);
 
   /**
-   * Get the aggregated number of vcores that the application has allocated
-   * times the number of seconds the application has been running.
-   * @return the aggregated number of vcore seconds
+   * Get the aggregated number of guaranteed vcores that the application has
+   * allocated times the number of seconds the application has been running.
+   * @return the aggregated number of guaranteed vcore seconds
+   */
+  @Public
+  @Unstable
+  public abstract long getGuaranteedVcoreSeconds();
+
+  /**
+   * Get the aggregated number of guaranteed vcores that the application has
+   * allocated times the number of seconds the application has been running.
+   * @return the aggregated number of guaranteed vcore seconds
    */
   @Public
   @Unstable
+  @Deprecated
   public abstract long getVcoreSeconds();
 
+  /**
+   * Get the aggregated amount of opportunistic memory (in megabytes) the
+   * application has allocated times the number of seconds the application
+   * has been running.
+   * @return the aggregated amount of opportunistic memory seconds
+   */
+  @Public
+  @Unstable
+  public abstract long getOpportunisticMemorySeconds();
+
+  /**
+   * Get the aggregated number of opportunistic vcores that the application
+   * has allocated times the number of seconds the application has been running.
+   * @return the aggregated number of opportunistic vcore seconds
+   */
+  @Public
+  @Unstable
+  public abstract long getOpportunisticVcoreSeconds();
+
   /**
    * Get the percentage of resources of the queue that the app is using.
    * @return the percentage of resources of the queue that the app is using.
@@ -231,23 +303,35 @@ public abstract class ApplicationResourceUsageReport {
   public abstract long getPreemptedVcoreSeconds();
 
   /**
-   * Get the aggregated number of resources that the application has
+   * Get the aggregated number of guaranteed resources that the application has
    * allocated times the number of seconds the application has been running.
-   * @return map containing the resource name and aggregated resource-seconds
+   * @return map containing the resource name and aggregated guaranteed
+   *         resource-seconds
    */
   @Public
   @Unstable
+  @Deprecated
   public abstract Map<String, Long> getResourceSecondsMap();
 
   /**
-   * Set the aggregated number of resources that the application has
+   * Get the aggregated number of guaranteed resources that the application has
+   * allocated times the number of seconds the application has been running.
+   * @return map containing the resource name and aggregated guaranteed
+   *         resource-seconds
+   */
+  @Public
+  @Unstable
+  public abstract Map<String, Long> getGuaranteedResourceSecondsMap();
+
+  /**
+   * Set the aggregated number of guaranteed resources that the application has
    * allocated times the number of seconds the application has been running.
    * @param resourceSecondsMap map containing the resource name and aggregated
-   *                           resource-seconds
+   *                           guaranteed resource-seconds
    */
   @Private
   @Unstable
-  public abstract void setResourceSecondsMap(
+  public abstract void setGuaranteedResourceSecondsMap(
       Map<String, Long> resourceSecondsMap);
 
 
@@ -272,4 +356,24 @@ public abstract class ApplicationResourceUsageReport {
   public abstract void setPreemptedResourceSecondsMap(
       Map<String, Long> preemptedResourceSecondsMap);
 
+  /**
+   * Get the aggregated number of opportunistic resources that the application
+   * has allocated times the number of seconds the application has been running.
+   * @return map containing the resource name and aggregated opportunistic
+   *         resource-seconds
+   */
+  @Public
+  @Unstable
+  public abstract Map<String, Long> getOpportunisticResourceSecondsMap();
+
+  /**
+   * Set the aggregated number of opportunistic resources that the application
+   * has allocated times the number of seconds the application has been running.
+   * @param opportunisticResourceSecondsMap map containing the resource name
+   *                               and aggregated opportunistic resource-seconds
+   */
+  @Private
+  @Unstable
+  public abstract void setOpportunisticResourceSecondsMap(
+      Map<String, Long> opportunisticResourceSecondsMap);
 }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/proto/yarn_protos.proto

@@ -252,6 +252,8 @@ message ApplicationResourceUsageReportProto {
   optional int64 preempted_vcore_seconds = 11;
   repeated StringLongMapProto application_resource_usage_map = 12;
   repeated StringLongMapProto application_preempted_resource_usage_map = 13;
+  optional ResourceProto used_opportunistic_resources = 14;
+  repeated StringLongMapProto application_opportunistic_resource_usage_map = 15;
 }
 
 message ApplicationReportProto {

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-client/src/main/java/org/apache/hadoop/yarn/client/cli/ApplicationCLI.java

@@ -1144,14 +1144,19 @@ public class ApplicationCLI extends YarnCLI {
 
   private void printResourceUsage(PrintWriter appReportStr,
       ApplicationResourceUsageReport usageReport) {
-    appReportStr.print("\tAggregate Resource Allocation : ");
+    appReportStr.print("\tAggregate Guaranteed Resource Allocation : ");
     if (usageReport != null) {
-      appReportStr.println(
-          getResourceSecondsString(usageReport.getResourceSecondsMap()));
+      appReportStr.println(getResourceSecondsString(
+          usageReport.getGuaranteedResourceSecondsMap()));
+      appReportStr.print("\tAggregate Opportunistic Resource Allocation : ");
+      appReportStr.println(getResourceSecondsString(
+          usageReport.getOpportunisticResourceSecondsMap()));
       appReportStr.print("\tAggregate Resource Preempted : ");
       appReportStr.println(getResourceSecondsString(
           usageReport.getPreemptedResourceSecondsMap()));
     } else {
+      appReportStr.println("N/A");
+      appReportStr.print("\tAggregate Opportunistic Resource Allocation : ");
       appReportStr.println("N/A");
       appReportStr.print("\tAggregate Resource Preempted : ");
       appReportStr.println("N/A");

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-client/src/main/java/org/apache/hadoop/yarn/client/cli/TopCLI.java

@@ -170,13 +170,11 @@ public class TopCLI extends YarnCLI {
           appReport.getApplicationResourceUsageReport()
             .getNumReservedContainers();
       displayStringsMap.put(Columns.RCONT, String.valueOf(reservedContainers));
-      usedVirtualCores =
-          appReport.getApplicationResourceUsageReport().getUsedResources()
-            .getVirtualCores();
+      usedVirtualCores = appReport.getApplicationResourceUsageReport()
+          .getGuaranteedResourcesUsed().getVirtualCores();
       displayStringsMap.put(Columns.VCORES, String.valueOf(usedVirtualCores));
-      usedMemory =
-          appReport.getApplicationResourceUsageReport().getUsedResources()
-            .getMemorySize() / 1024;
+      usedMemory = appReport.getApplicationResourceUsageReport()
+          .getGuaranteedResourcesUsed().getMemorySize() / 1024;
       displayStringsMap.put(Columns.MEM, String.valueOf(usedMemory) + "G");
       reservedVirtualCores =
           appReport.getApplicationResourceUsageReport().getReservedResources()
@@ -195,11 +193,11 @@ public class TopCLI extends YarnCLI {
       progress = appReport.getProgress() * 100;
       displayStringsMap.put(Columns.PROGRESS, String.format("%.2f", progress));
       // store in GBSeconds
-      memorySeconds =
-          appReport.getApplicationResourceUsageReport().getMemorySeconds() / 1024;
+      memorySeconds = appReport.getApplicationResourceUsageReport()
+          .getGuaranteedMemorySeconds() / 1024;
       displayStringsMap.put(Columns.MEMSECS, String.valueOf(memorySeconds));
-      vcoreSeconds =
-          appReport.getApplicationResourceUsageReport().getVcoreSeconds();
+      vcoreSeconds = appReport.getApplicationResourceUsageReport()
+          .getGuaranteedVcoreSeconds();
       displayStringsMap.put(Columns.VCORESECS, String.valueOf(vcoreSeconds));
     }
   }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-client/src/test/java/org/apache/hadoop/yarn/client/cli/TestYarnCLI.java

@@ -123,18 +123,27 @@ public class TestYarnCLI {
     for (int i = 0; i < 2; ++i) {
       ApplicationCLI cli = createAndGetAppCLI();
       ApplicationId applicationId = ApplicationId.newInstance(1234, 5);
-      Map<String, Long> resourceSecondsMap = new HashMap<>();
+      Map<String, Long> guaranteedResourceSecondsMap = new HashMap<>();
+      Map<String, Long> opportunisticResourceSecondsMap = new HashMap<>();
       Map<String, Long> preemptedResoureSecondsMap = new HashMap<>();
-      resourceSecondsMap.put(ResourceInformation.MEMORY_MB.getName(), 123456L);
-      resourceSecondsMap.put(ResourceInformation.VCORES.getName(), 4567L);
+      guaranteedResourceSecondsMap.put(
+          ResourceInformation.MEMORY_MB.getName(), 123456L);
+      guaranteedResourceSecondsMap.put(
+          ResourceInformation.VCORES.getName(), 4567L);
+      opportunisticResourceSecondsMap.put(
+          ResourceInformation.MEMORY_MB.getName(), 123456L);
+      opportunisticResourceSecondsMap.put(
+          ResourceInformation.VCORES.getName(), 4567L);
       preemptedResoureSecondsMap
           .put(ResourceInformation.MEMORY_MB.getName(), 1111L);
       preemptedResoureSecondsMap
           .put(ResourceInformation.VCORES.getName(), 2222L);
       ApplicationResourceUsageReport usageReport = i == 0 ? null :
           ApplicationResourceUsageReport
-              .newInstance(2, 0, null, null, null, resourceSecondsMap, 0, 0,
-                  preemptedResoureSecondsMap);
+              .newInstance(2, 0, null, null, null,
+                  guaranteedResourceSecondsMap, 0, 0,
+                  preemptedResoureSecondsMap, null,
+                  opportunisticResourceSecondsMap);
       ApplicationReport newApplicationReport = ApplicationReport.newInstance(
           applicationId, ApplicationAttemptId.newInstance(applicationId, 1),
           "user", "queue", "appname", "host", 124, null,
@@ -170,7 +179,9 @@ public class TestYarnCLI {
       pw.println("\tTracking-URL : N/A");
       pw.println("\tRPC Port : 124");
       pw.println("\tAM Host : host");
-      pw.println("\tAggregate Resource Allocation : " +
+      pw.println("\tAggregate Guaranteed Resource Allocation : " +
+          (i == 0 ? "N/A" : "123456 MB-seconds, 4567 vcore-seconds"));
+      pw.println("\tAggregate Opportunistic Resource Allocation : " +
           (i == 0 ? "N/A" : "123456 MB-seconds, 4567 vcore-seconds"));
       pw.println("\tAggregate Resource Preempted : " +
           (i == 0 ? "N/A" : "1111 MB-seconds, 2222 vcore-seconds"));

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/api/records/impl/pb/ApplicationResourceUsageReportPBImpl.java

@@ -40,12 +40,14 @@ extends ApplicationResourceUsageReport {
   ApplicationResourceUsageReportProto.Builder builder = null;
   boolean viaProto = false;
 
-  Resource usedResources;
-  Resource reservedResources;
-  Resource neededResources;
+  private Resource guaranteedResourceUsed;
+  private Resource reservedResources;
+  private Resource neededResources;
+  private Resource opportunisticResourceUsed;
 
-  private Map<String, Long> resourceSecondsMap;
+  private Map<String, Long> guaranteedResourceSecondsMap;
   private Map<String, Long> preemptedResourceSecondsMap;
+  private Map<String, Long> opportunisticResourceSecondsMap;
 
   public ApplicationResourceUsageReportPBImpl() {
     builder = ApplicationResourceUsageReportProto.newBuilder();
@@ -55,8 +57,9 @@ extends ApplicationResourceUsageReport {
       ApplicationResourceUsageReportProto proto) {
     this.proto = proto;
     viaProto = true;
-    getResourceSecondsMap();
+    getGuaranteedResourceSecondsMap();
     getPreemptedResourceSecondsMap();
+    getOpportunisticResourceSecondsMap();
   }
 
   public synchronized ApplicationResourceUsageReportProto getProto() {
@@ -87,8 +90,13 @@ extends ApplicationResourceUsageReport {
   }
 
   private void mergeLocalToBuilder() {
-    if (this.usedResources != null) {
-      builder.setUsedResources(convertToProtoFormat(this.usedResources));
+    if (this.guaranteedResourceUsed != null) {
+      builder.setUsedResources(
+          convertToProtoFormat(this.guaranteedResourceUsed));
+    }
+    if (this.opportunisticResourceUsed != null) {
+      builder.setUsedOpportunisticResources(
+          convertToProtoFormat(this.opportunisticResourceUsed));
     }
     if (this.reservedResources != null) {
       builder.setReservedResources(
@@ -99,19 +107,28 @@ extends ApplicationResourceUsageReport {
     }
     builder.clearApplicationResourceUsageMap();
     builder.clearApplicationPreemptedResourceUsageMap();
+    builder.clearApplicationOpportunisticResourceUsageMap();
 
     if (preemptedResourceSecondsMap != null && !preemptedResourceSecondsMap
         .isEmpty()) {
       builder.addAllApplicationPreemptedResourceUsageMap(ProtoUtils
           .convertMapToStringLongMapProtoList(preemptedResourceSecondsMap));
     }
-    if (resourceSecondsMap != null && !resourceSecondsMap.isEmpty()) {
+    if (guaranteedResourceSecondsMap != null &&
+        !guaranteedResourceSecondsMap.isEmpty()) {
       builder.addAllApplicationResourceUsageMap(
-          ProtoUtils.convertMapToStringLongMapProtoList(resourceSecondsMap));
+          ProtoUtils.convertMapToStringLongMapProtoList(
+              guaranteedResourceSecondsMap));
+    }
+    if (opportunisticResourceSecondsMap != null &&
+        !opportunisticResourceSecondsMap.isEmpty()) {
+      builder.addAllApplicationOpportunisticResourceUsageMap(
+          ProtoUtils.convertMapToStringLongMapProtoList(
+              opportunisticResourceSecondsMap));
     }
 
-    builder.setMemorySeconds(this.getMemorySeconds());
-    builder.setVcoreSeconds(this.getVcoreSeconds());
+    builder.setMemorySeconds(this.getGuaranteedMemorySeconds());
+    builder.setVcoreSeconds(this.getGuaranteedVcoreSeconds());
     builder.setPreemptedMemorySeconds(this.getPreemptedMemorySeconds());
     builder.setPreemptedVcoreSeconds(this.getPreemptedVcoreSeconds());
   }
@@ -157,24 +174,53 @@ extends ApplicationResourceUsageReport {
   }
 
   @Override
+  @Deprecated
   public synchronized Resource getUsedResources() {
+    return getGuaranteedResourcesUsed();
+  }
+
+  @Override
+  public synchronized Resource getGuaranteedResourcesUsed() {
     ApplicationResourceUsageReportProtoOrBuilder p = viaProto ? proto : builder;
-    if (this.usedResources != null) {
-      return this.usedResources;
+    if (this.guaranteedResourceUsed != null) {
+      return this.guaranteedResourceUsed;
     }
     if (!p.hasUsedResources()) {
       return null;
     }
-    this.usedResources = convertFromProtoFormat(p.getUsedResources());
-    return this.usedResources;
+    this.guaranteedResourceUsed = convertFromProtoFormat(p.getUsedResources());
+    return this.guaranteedResourceUsed;
   }
 
   @Override
-  public synchronized void setUsedResources(Resource resources) {
+  public synchronized void setGuaranteedResourcesUsed(Resource resources) {
     maybeInitBuilder();
     if (resources == null)
       builder.clearUsedResources();
-    this.usedResources = resources;
+    this.guaranteedResourceUsed = resources;
+  }
+
+  @Override
+  public synchronized Resource getOpportunisticResourcesUsed() {
+    ApplicationResourceUsageReportProtoOrBuilder p = viaProto ? proto : builder;
+    if (this.opportunisticResourceUsed != null) {
+      return this.opportunisticResourceUsed;
+    }
+    if (!p.hasUsedOpportunisticResources()) {
+      return null;
+    }
+    this.opportunisticResourceUsed =
+        convertFromProtoFormat(p.getUsedOpportunisticResources());
+    return this.opportunisticResourceUsed;
+  }
+
+  @Override
+  public synchronized void setOpportunisticResourcesUsed(Resource resources) {
+    maybeInitBuilder();
+    if (resources == null) {
+      builder.clearUsedOpportunisticResources();
+    }
+    this.opportunisticResourceUsed = resources;
   }
 
   @Override
@@ -220,14 +266,14 @@ extends ApplicationResourceUsageReport {
   }
 
   @Override
-  public synchronized void setMemorySeconds(long memory_seconds) {
-    getResourceSecondsMap()
-        .put(ResourceInformation.MEMORY_MB.getName(), memory_seconds);
+  public synchronized void setGuaranteedMemorySeconds(long memorySeconds) {
+    getGuaranteedResourceSecondsMap()
+        .put(ResourceInformation.MEMORY_MB.getName(), memorySeconds);
   }
 
   @Override
-  public synchronized long getMemorySeconds() {
-    Map<String, Long> tmp = getResourceSecondsMap();
+  public synchronized long getGuaranteedMemorySeconds() {
+    Map<String, Long> tmp = getGuaranteedResourceSecondsMap();
     if (tmp.containsKey(ResourceInformation.MEMORY_MB.getName())) {
       return tmp.get(ResourceInformation.MEMORY_MB.getName());
     }
@@ -235,20 +281,50 @@ extends ApplicationResourceUsageReport {
   }
 
   @Override
-  public synchronized void setVcoreSeconds(long vcore_seconds) {
-    getResourceSecondsMap()
-        .put(ResourceInformation.VCORES.getName(), vcore_seconds);
+  @Deprecated
+  public synchronized long getMemorySeconds() {
+    return getGuaranteedMemorySeconds();
+  }
+
+  @Override
+  public synchronized void setGuaranteedVcoreSeconds(long vcoreSeconds) {
+    getGuaranteedResourceSecondsMap()
+        .put(ResourceInformation.VCORES.getName(), vcoreSeconds);
   }
 
   @Override
+  public synchronized long getGuaranteedVcoreSeconds() {
+    Map<String, Long> tmp = getGuaranteedResourceSecondsMap();
+    if (tmp.containsKey(ResourceInformation.VCORES.getName())) {
+      return tmp.get(ResourceInformation.VCORES.getName());
+    }
+    return 0;
+  }
+
+  @Override
+  @Deprecated
   public synchronized long getVcoreSeconds() {
-    Map<String, Long> tmp = getResourceSecondsMap();
+    return getGuaranteedVcoreSeconds();
+  }
+
+  @Override
+  public synchronized long getOpportunisticMemorySeconds() {
+    Map<String, Long> tmp = getOpportunisticResourceSecondsMap();
+    if (tmp.containsKey(ResourceInformation.MEMORY_MB.getName())) {
+      return tmp.get(ResourceInformation.MEMORY_MB.getName());
+    }
+    return 0;
+  }
+
+  @Override
+  public synchronized long getOpportunisticVcoreSeconds() {
+    Map<String, Long> tmp = getOpportunisticResourceSecondsMap();
     if (tmp.containsKey(ResourceInformation.VCORES.getName())) {
       return tmp.get(ResourceInformation.VCORES.getName());
     }
     return 0;
   }
-  
+
   @Override
   public synchronized void setPreemptedMemorySeconds(
       long preemptedMemorySeconds) {
@@ -314,41 +390,47 @@ extends ApplicationResourceUsageReport {
   }
 
   @Override
-  public synchronized void setResourceSecondsMap(
+  public synchronized void setGuaranteedResourceSecondsMap(
       Map<String, Long> resourceSecondsMap) {
-    this.resourceSecondsMap = resourceSecondsMap;
+    this.guaranteedResourceSecondsMap = resourceSecondsMap;
     if (resourceSecondsMap == null) {
       return;
     }
     if (!resourceSecondsMap
         .containsKey(ResourceInformation.MEMORY_MB.getName())) {
-      this.setMemorySeconds(0L);
+      this.setGuaranteedMemorySeconds(0L);
     }
     if (!resourceSecondsMap.containsKey(ResourceInformation.VCORES.getName())) {
-      this.setVcoreSeconds(0L);
+      this.setGuaranteedVcoreSeconds(0L);
     }
   }
 
   @Override
+  @Deprecated
   public synchronized Map<String, Long> getResourceSecondsMap() {
-    if (this.resourceSecondsMap != null) {
-      return this.resourceSecondsMap;
+    return getGuaranteedResourceSecondsMap();
+  }
+
+  @Override
+  public synchronized Map<String, Long> getGuaranteedResourceSecondsMap() {
+    if (this.guaranteedResourceSecondsMap != null) {
+      return this.guaranteedResourceSecondsMap;
     }
     ApplicationResourceUsageReportProtoOrBuilder p = viaProto ? proto : builder;
-    this.resourceSecondsMap = ProtoUtils
+    this.guaranteedResourceSecondsMap = ProtoUtils
         .convertStringLongMapProtoListToMap(
             p.getApplicationResourceUsageMapList());
-    if (!this.resourceSecondsMap
+    if (!this.guaranteedResourceSecondsMap
         .containsKey(ResourceInformation.MEMORY_MB.getName())) {
-      this.setMemorySeconds(p.getMemorySeconds());
+      this.setGuaranteedMemorySeconds(p.getMemorySeconds());
     }
-    if (!this.resourceSecondsMap
+    if (!this.guaranteedResourceSecondsMap
         .containsKey(ResourceInformation.VCORES.getName())) {
-      this.setVcoreSeconds(p.getVcoreSeconds());
+      this.setGuaranteedVcoreSeconds(p.getVcoreSeconds());
     }
-    this.setMemorySeconds(p.getMemorySeconds());
-    this.setVcoreSeconds(p.getVcoreSeconds());
-    return this.resourceSecondsMap;
+    this.setGuaranteedMemorySeconds(p.getMemorySeconds());
+    this.setGuaranteedVcoreSeconds(p.getVcoreSeconds());
+    return this.guaranteedResourceSecondsMap;
   }
 
   @Override
@@ -389,4 +471,45 @@ extends ApplicationResourceUsageReport {
     this.setPreemptedVcoreSeconds(p.getPreemptedVcoreSeconds());
     return this.preemptedResourceSecondsMap;
   }
+
+  @Override
+  public synchronized Map<String, Long> getOpportunisticResourceSecondsMap() {
+    if (this.opportunisticResourceSecondsMap != null) {
+      return this.opportunisticResourceSecondsMap;
+    }
+    ApplicationResourceUsageReportProtoOrBuilder p = viaProto ? proto : builder;
+    this.opportunisticResourceSecondsMap = ProtoUtils
+        .convertStringLongMapProtoListToMap(
+            p.getApplicationOpportunisticResourceUsageMapList());
+    if (!opportunisticResourceSecondsMap.containsKey(
+        ResourceInformation.MEMORY_MB.getName())) {
+      this.opportunisticResourceSecondsMap.put(
+          ResourceInformation.MEMORY_MB.getName(), 0L);
+    }
+    if (!opportunisticResourceSecondsMap.containsKey(
+        ResourceInformation.VCORES.getName())) {
+      this.opportunisticResourceSecondsMap.put(
+          ResourceInformation.VCORES.getName(), 0L);
+    }
+    return this.opportunisticResourceSecondsMap;
+  }
+
+  @Override
+  public synchronized void setOpportunisticResourceSecondsMap(
+      Map<String, Long> opportunisticResourceSecondsMap) {
+    this.opportunisticResourceSecondsMap = opportunisticResourceSecondsMap;
+    if (opportunisticResourceSecondsMap == null) {
+      return;
+    }
+    if (!opportunisticResourceSecondsMap
+        .containsKey(ResourceInformation.MEMORY_MB.getName())) {
+      this.opportunisticResourceSecondsMap.put(
+          ResourceInformation.MEMORY_MB.getName(), 0L);
+    }
+    if (!opportunisticResourceSecondsMap
+        .containsKey(ResourceInformation.VCORES.getName())) {
+      this.opportunisticResourceSecondsMap.put(
+          ResourceInformation.VCORES.getName(), 0L);
+    }
+  }
 }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java/org/apache/hadoop/yarn/util/resource/Resources.java

@@ -28,6 +28,8 @@ import org.apache.hadoop.yarn.api.records.ResourceInformation;
 import org.apache.hadoop.yarn.api.records.impl.LightWeightResource;
 import org.apache.hadoop.yarn.exceptions.ResourceNotFoundException;
 
+import java.util.Map;
+
 /**
  * Resources is a computation class which provides a set of apis to do
  * mathematical operations on Resource object.
@@ -553,4 +555,22 @@ public class Resources {
       Resource resource, Resource factor) {
     return calculator.normalizeDown(resource, factor);
   }
+
+  /**
+   * Merge resource usage entries from a map to another map.
+   * @param mergeFrom the map to merge from
+   * @param mergeTo the map to merge to
+   */
+  public static void mergeResourceSecondsMap(Map<String, Long> mergeFrom,
+      Map<String, Long> mergeTo) {
+    for (Map.Entry<String, Long> entry : mergeFrom.entrySet()) {
+      Long value = mergeTo.get(entry.getKey());
+      if (value != null) {
+        value += entry.getValue();
+      } else {
+        value = entry.getValue();
+      }
+      mergeTo.put(entry.getKey(), value);
+    }
+  }
 }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-applicationhistoryservice/src/main/java/org/apache/hadoop/yarn/server/applicationhistoryservice/ApplicationHistoryManagerOnTimelineStore.java

@@ -64,7 +64,6 @@ import org.apache.hadoop.yarn.server.security.ApplicationACLsManager;
 import org.apache.hadoop.yarn.server.timeline.NameValuePair;
 import org.apache.hadoop.yarn.server.timeline.TimelineDataManager;
 import org.apache.hadoop.yarn.server.timeline.TimelineReader.Field;
-import org.apache.hadoop.yarn.util.ConverterUtils;
 import org.apache.hadoop.yarn.webapp.util.WebAppUtils;
 
 import com.google.common.annotations.VisibleForTesting;
@@ -330,29 +329,19 @@ public class ApplicationHistoryManagerOnTimelineStore extends AbstractService
                 .toString();
       }
 
-      if (entityInfo.containsKey(ApplicationMetricsConstants.APP_CPU_METRICS)) {
-        long vcoreSeconds = parseLong(entityInfo,
-            ApplicationMetricsConstants.APP_CPU_METRICS);
-        long memorySeconds = parseLong(entityInfo,
-            ApplicationMetricsConstants.APP_MEM_METRICS);
-        long preemptedMemorySeconds = parseLong(entityInfo,
-            ApplicationMetricsConstants.APP_MEM_PREEMPT_METRICS);
-        long preemptedVcoreSeconds = parseLong(entityInfo,
-            ApplicationMetricsConstants.APP_CPU_PREEMPT_METRICS);
-        Map<String, Long> resourceSecondsMap = new HashMap<>();
-        Map<String, Long> preemptedResoureSecondsMap = new HashMap<>();
-        resourceSecondsMap
-            .put(ResourceInformation.MEMORY_MB.getName(), memorySeconds);
-        resourceSecondsMap
-            .put(ResourceInformation.VCORES.getName(), vcoreSeconds);
-        preemptedResoureSecondsMap.put(ResourceInformation.MEMORY_MB.getName(),
-            preemptedMemorySeconds);
-        preemptedResoureSecondsMap
-            .put(ResourceInformation.VCORES.getName(), preemptedVcoreSeconds);
-
+      if (entityInfo.containsKey(
+          ApplicationMetricsConstants.APP_GUARANTEED_CPU_METRICS)) {
+        Map<String, Long> guaranteedResourceSecondsMap =
+            extractGuaranteedResourceSecondsMap(entityInfo);
+        Map<String, Long> preemptedResoureSecondsMap =
+            extractPreemptedResourceSecondsMap(entityInfo);
+        Map<String, Long> opportunisticResourceSecondsMap =
+            extractOpportunisticResourceSecondsMap(entityInfo);
         appResources = ApplicationResourceUsageReport
-            .newInstance(0, 0, null, null, null, resourceSecondsMap, 0, 0,
-                preemptedResoureSecondsMap);
+            .newInstance(0, 0, null, null, null,
+                guaranteedResourceSecondsMap, 0, 0,
+                preemptedResoureSecondsMap, null,
+                opportunisticResourceSecondsMap);
       }
 
       if (entityInfo.containsKey(ApplicationMetricsConstants.APP_TAGS_INFO)) {
@@ -456,6 +445,54 @@ public class ApplicationHistoryManagerOnTimelineStore extends AbstractService
         amNodeLabelExpression), appViewACLs);
   }
 
+  private static Map<String, Long> extractGuaranteedResourceSecondsMap(
+      Map<String, Object> entityInfo) {
+    Map<String, Long> guaranteedResourceSecondsMap = new HashMap<>();
+
+    long guaranteedVcoreSeconds = parseLong(entityInfo,
+        ApplicationMetricsConstants.APP_GUARANTEED_CPU_METRICS);
+    long guaranteedMemorySeconds = parseLong(entityInfo,
+        ApplicationMetricsConstants.APP_GUARANTEED_MEM_METRICS);
+    guaranteedResourceSecondsMap.put(
+        ResourceInformation.MEMORY_MB.getName(), guaranteedMemorySeconds);
+    guaranteedResourceSecondsMap.put(ResourceInformation.VCORES.getName(),
+        guaranteedVcoreSeconds);
+
+    return guaranteedResourceSecondsMap;
+  }
+
+  private static Map<String, Long> extractOpportunisticResourceSecondsMap(
+      Map<String, Object> entityInfo) {
+    Map<String, Long> opportunisticResourceSecondsMap = new HashMap<>();
+
+    long opportunisticVcoreSeconds = parseLong(entityInfo,
+        ApplicationMetricsConstants.APP_OPPORTUNISTIC_CPU_METRICS);
+    long opportunisticMemorySeconds = parseLong(entityInfo,
+        ApplicationMetricsConstants.APP_OPPORTUNISTIC_MEM_METRICS);
+    opportunisticResourceSecondsMap.put(
+        ResourceInformation.MEMORY_MB.getName(),
+        opportunisticMemorySeconds);
+    opportunisticResourceSecondsMap.put(
+        ResourceInformation.VCORES.getName(), opportunisticVcoreSeconds);
+
+    return opportunisticResourceSecondsMap;
+  }
+
+  private static Map<String, Long> extractPreemptedResourceSecondsMap(
+      Map<String, Object> entityInfo) {
+    Map<String, Long> preemptedResoureSecondsMap = new HashMap<>();
+
+    long preemptedMemorySeconds = parseLong(entityInfo,
+        ApplicationMetricsConstants.APP_MEM_PREEMPT_METRICS);
+    long preemptedVcoreSeconds = parseLong(entityInfo,
+        ApplicationMetricsConstants.APP_CPU_PREEMPT_METRICS);
+    preemptedResoureSecondsMap.put(ResourceInformation.MEMORY_MB.getName(),
+        preemptedMemorySeconds);
+    preemptedResoureSecondsMap
+        .put(ResourceInformation.VCORES.getName(), preemptedVcoreSeconds);
+
+    return preemptedResoureSecondsMap;
+  }
   private static long parseLong(Map<String, Object> entityInfo,
       String infoKey) {
     long result = 0;

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-applicationhistoryservice/src/test/java/org/apache/hadoop/yarn/server/applicationhistoryservice/TestApplicationHistoryClientService.java

@@ -152,9 +152,13 @@ public class TestApplicationHistoryClientService {
     ApplicationReport appReport = response.getApplicationReport();
     Assert.assertNotNull(appReport);
     Assert.assertEquals(123, appReport.getApplicationResourceUsageReport()
-        .getMemorySeconds());
+        .getGuaranteedMemorySeconds());
     Assert.assertEquals(345, appReport.getApplicationResourceUsageReport()
-        .getVcoreSeconds());
+        .getGuaranteedVcoreSeconds());
+    Assert.assertEquals(123, appReport.getApplicationResourceUsageReport()
+        .getOpportunisticMemorySeconds());
+    Assert.assertEquals(345, appReport.getApplicationResourceUsageReport()
+        .getOpportunisticVcoreSeconds());
     Assert.assertEquals("application_0_0001", appReport.getApplicationId()
       .toString());
     Assert.assertEquals("test app type",

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-applicationhistoryservice/src/test/java/org/apache/hadoop/yarn/server/applicationhistoryservice/TestApplicationHistoryManagerOnTimelineStore.java

@@ -250,9 +250,13 @@ public class TestApplicationHistoryManagerOnTimelineStore {
       ApplicationResourceUsageReport applicationResourceUsageReport =
           app.getApplicationResourceUsageReport();
       Assert.assertEquals(123,
-          applicationResourceUsageReport.getMemorySeconds());
-      Assert
-          .assertEquals(345, applicationResourceUsageReport.getVcoreSeconds());
+          applicationResourceUsageReport.getGuaranteedMemorySeconds());
+      Assert.assertEquals(345,
+          applicationResourceUsageReport.getGuaranteedVcoreSeconds());
+      Assert.assertEquals(123,
+          applicationResourceUsageReport.getOpportunisticMemorySeconds());
+      Assert.assertEquals(345,
+          applicationResourceUsageReport.getOpportunisticVcoreSeconds());
       long expectedPreemptMemSecs = 456;
       long expectedPreemptVcoreSecs = 789;
       if (i == 3) {
@@ -534,8 +538,12 @@ public class TestApplicationHistoryManagerOnTimelineStore {
         Priority.newInstance(0));
     entityInfo.put(ApplicationMetricsConstants.SUBMITTED_TIME_ENTITY_INFO,
         Integer.MAX_VALUE + 1L);
-    entityInfo.put(ApplicationMetricsConstants.APP_MEM_METRICS, 123);
-    entityInfo.put(ApplicationMetricsConstants.APP_CPU_METRICS, 345);
+    entityInfo.put(ApplicationMetricsConstants.APP_GUARANTEED_MEM_METRICS, 123);
+    entityInfo.put(ApplicationMetricsConstants.APP_GUARANTEED_CPU_METRICS, 345);
+    entityInfo.put(
+        ApplicationMetricsConstants.APP_OPPORTUNISTIC_MEM_METRICS, 123);
+    entityInfo.put(
+        ApplicationMetricsConstants.APP_OPPORTUNISTIC_CPU_METRICS, 345);
     if (!missingPreemptMetrics) {
       entityInfo.put(ApplicationMetricsConstants.APP_MEM_PREEMPT_METRICS, 456);
       entityInfo.put(ApplicationMetricsConstants.APP_CPU_PREEMPT_METRICS, 789);

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-common/src/main/java/org/apache/hadoop/yarn/server/metrics/ApplicationMetricsConstants.java

@@ -70,12 +70,18 @@ public class ApplicationMetricsConstants {
   public static final String STATE_EVENT_INFO =
       "YARN_APPLICATION_STATE";
   
-  public static final String APP_CPU_METRICS =
+  public static final String APP_GUARANTEED_CPU_METRICS =
       "YARN_APPLICATION_CPU";
   
-  public static final String APP_MEM_METRICS =
+  public static final String APP_GUARANTEED_MEM_METRICS =
       "YARN_APPLICATION_MEMORY";
 
+  public static final String APP_OPPORTUNISTIC_CPU_METRICS =
+      "YARN_APPLICATION_OPPORTUNISTIC_CPU";
+
+  public static final String APP_OPPORTUNISTIC_MEM_METRICS =
+      "YARN_APPLICATION_OPPORTUNISTIC_MEMORY";
+
   public static final String APP_RESOURCE_PREEMPTED_CPU =
       "YARN_APPLICATION_RESOURCE_PREEMPTED_CPU";
 

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-common/src/main/java/org/apache/hadoop/yarn/server/utils/BuilderUtils.java

@@ -456,19 +456,24 @@ public class BuilderUtils {
   }
 
   public static ApplicationResourceUsageReport newApplicationResourceUsageReport(
-      int numUsedContainers, int numReservedContainers, Resource usedResources,
+      int numUsedContainers, int numReservedContainers,
+      Resource guaranteedResourcesUsed,
       Resource reservedResources, Resource neededResources,
-      Map<String, Long> resourceSecondsMap,
-      Map<String, Long> preemptedResourceSecondsMap) {
+      Map<String, Long> guaranteedResourceSecondsMap,
+      Map<String, Long> preemptedResourceSecondsMap,
+      Resource opportunisticResourcesUsed,
+      Map<String, Long> opportunisticResourcesSecondsMap) {
     ApplicationResourceUsageReport report =
         recordFactory.newRecordInstance(ApplicationResourceUsageReport.class);
     report.setNumUsedContainers(numUsedContainers);
     report.setNumReservedContainers(numReservedContainers);
-    report.setUsedResources(usedResources);
+    report.setGuaranteedResourcesUsed(guaranteedResourcesUsed);
     report.setReservedResources(reservedResources);
     report.setNeededResources(neededResources);
-    report.setResourceSecondsMap(resourceSecondsMap);
+    report.setGuaranteedResourceSecondsMap(guaranteedResourceSecondsMap);
     report.setPreemptedResourceSecondsMap(preemptedResourceSecondsMap);
+    report.setOpportunisticResourcesUsed(opportunisticResourcesUsed);
+    report.setOpportunisticResourceSecondsMap(opportunisticResourcesSecondsMap);
     return report;
   }
 

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-common/src/main/java/org/apache/hadoop/yarn/server/webapp/dao/AppInfo.java

@@ -29,6 +29,7 @@ import org.apache.hadoop.classification.InterfaceStability.Evolving;
 
 import org.apache.hadoop.yarn.api.records.ApplicationReport;
 import org.apache.hadoop.yarn.api.records.FinalApplicationStatus;
+import org.apache.hadoop.yarn.api.records.Resource;
 import org.apache.hadoop.yarn.api.records.YarnApplicationState;
 import org.apache.hadoop.yarn.util.Times;
 
@@ -62,6 +63,8 @@ public class AppInfo {
   protected int priority;
   private long allocatedCpuVcores;
   private long allocatedMemoryMB;
+  private long allocatedOpportunisticCpuVcores;
+  private long allocatedOpportunisticMemoryMB;
   private long reservedCpuVcores;
   private long reservedMemoryMB;
   protected boolean unmanagedApplication;
@@ -100,15 +103,25 @@ public class AppInfo {
     if (app.getApplicationResourceUsageReport() != null) {
       runningContainers = app.getApplicationResourceUsageReport()
           .getNumUsedContainers();
-      if (app.getApplicationResourceUsageReport().getUsedResources() != null) {
-        allocatedCpuVcores = app.getApplicationResourceUsageReport()
-            .getUsedResources().getVirtualCores();
-        allocatedMemoryMB = app.getApplicationResourceUsageReport()
-            .getUsedResources().getMemorySize();
-        reservedCpuVcores = app.getApplicationResourceUsageReport()
-            .getReservedResources().getVirtualCores();
-        reservedMemoryMB = app.getApplicationResourceUsageReport()
-            .getReservedResources().getMemorySize();
+      Resource guaranteedResourceUsed =
+          app.getApplicationResourceUsageReport().getGuaranteedResourcesUsed();
+      if (guaranteedResourceUsed != null) {
+        allocatedCpuVcores = guaranteedResourceUsed.getVirtualCores();
+        allocatedMemoryMB = guaranteedResourceUsed.getMemorySize();
+      }
+      Resource opportunisticResourceUsed = app
+          .getApplicationResourceUsageReport().getOpportunisticResourcesUsed();
+      if (opportunisticResourceUsed != null) {
+        allocatedOpportunisticCpuVcores =
+            opportunisticResourceUsed.getVirtualCores();
+        allocatedOpportunisticMemoryMB =
+            opportunisticResourceUsed.getMemorySize();
+      }
+      Resource resourceReserved =
+          app.getApplicationResourceUsageReport().getReservedResources();
+      if (resourceReserved != null) {
+        reservedCpuVcores = resourceReserved.getVirtualCores();
+        reservedMemoryMB = resourceReserved.getMemorySize();
       }
     }
     progress = app.getProgress() * 100; // in percent
@@ -168,6 +181,14 @@ public class AppInfo {
     return allocatedMemoryMB;
   }
 
+  public long getAllocatedOpportunisticCpuVcores() {
+    return allocatedOpportunisticCpuVcores;
+  }
+
+  public long getAllocatedOpportunisticMemoryMB() {
+    return allocatedOpportunisticMemoryMB;
+  }
+
   public long getReservedCpuVcores() {
     return reservedCpuVcores;
   }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/RMAppManager.java

@@ -186,19 +186,27 @@ public class RMAppManager implements EventHandler<RMAppManagerEvent>,
           .add("startTime", app.getStartTime())
           .add("finishTime", app.getFinishTime())
           .add("finalStatus", app.getFinalApplicationStatus())
-          .add("memorySeconds", metrics.getMemorySeconds())
-          .add("vcoreSeconds", metrics.getVcoreSeconds())
+          .add("guaranteedMemorySeconds", metrics.getGuaranteedMemorySeconds())
+          .add("guaranteedVcoreSeconds", metrics.getGuaranteedVcoreSeconds())
+          .add("opportunisticMemorySeconds",
+              metrics.getOpportunisticMemorySeconds())
+          .add("opportunisticVcoreSeconds",
+              metrics.getOpportunisticVcoreSeconds())
           .add("preemptedMemorySeconds", metrics.getPreemptedMemorySeconds())
           .add("preemptedVcoreSeconds", metrics.getPreemptedVcoreSeconds())
           .add("preemptedAMContainers", metrics.getNumAMContainersPreempted())
           .add("preemptedNonAMContainers", metrics.getNumNonAMContainersPreempted())
           .add("preemptedResources", metrics.getResourcePreempted())
           .add("applicationType", app.getApplicationType())
-          .add("resourceSeconds", StringHelper
-              .getResourceSecondsString(metrics.getResourceSecondsMap()))
+          .add("guaranteedResourceSeconds", StringHelper
+              .getResourceSecondsString(
+                  metrics.getGuaranteedResourceSecondsMap()))
           .add("preemptedResourceSeconds", StringHelper
               .getResourceSecondsString(
-                  metrics.getPreemptedResourceSecondsMap()));
+                  metrics.getPreemptedResourceSecondsMap()))
+          .add("opportunisticResourceSeconds", StringHelper
+              .getResourceSecondsString(
+                  metrics.getOpportunisticResourceSecondsMap()));
       return summary;
     }
 

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/RMServerUtils.java

@@ -481,7 +481,8 @@ public class RMServerUtils {
       DUMMY_APPLICATION_RESOURCE_USAGE_REPORT =
       BuilderUtils.newApplicationResourceUsageReport(-1, -1,
           Resources.createResource(-1, -1), Resources.createResource(-1, -1),
-          Resources.createResource(-1, -1), new HashMap<>(), new HashMap<>());
+          Resources.createResource(-1, -1), new HashMap<>(), new HashMap<>(),
+          Resources.createResource(-1, -1), new HashMap<>());
 
 
   /**

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/metrics/TimelineServiceV1Publisher.java

@@ -142,10 +142,16 @@ public class TimelineServiceV1Publisher extends AbstractSystemMetricsPublisher {
           latestApplicationAttemptId);
     }
     RMAppMetrics appMetrics = app.getRMAppMetrics();
-    entity.addOtherInfo(ApplicationMetricsConstants.APP_CPU_METRICS,
-        appMetrics.getVcoreSeconds());
-    entity.addOtherInfo(ApplicationMetricsConstants.APP_MEM_METRICS,
-        appMetrics.getMemorySeconds());
+    entity.addOtherInfo(ApplicationMetricsConstants.APP_GUARANTEED_CPU_METRICS,
+        appMetrics.getGuaranteedVcoreSeconds());
+    entity.addOtherInfo(ApplicationMetricsConstants.APP_GUARANTEED_MEM_METRICS,
+        appMetrics.getGuaranteedMemorySeconds());
+    entity.addOtherInfo(
+        ApplicationMetricsConstants.APP_OPPORTUNISTIC_CPU_METRICS,
+        appMetrics.getOpportunisticVcoreSeconds());
+    entity.addOtherInfo(
+        ApplicationMetricsConstants.APP_OPPORTUNISTIC_MEM_METRICS,
+        appMetrics.getOpportunisticMemorySeconds());
     entity.addOtherInfo(ApplicationMetricsConstants.APP_MEM_PREEMPT_METRICS,
             appMetrics.getPreemptedMemorySeconds());
     entity.addOtherInfo(ApplicationMetricsConstants.APP_CPU_PREEMPT_METRICS,

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/metrics/TimelineServiceV2Publisher.java

@@ -193,11 +193,17 @@ public class TimelineServiceV2Publisher extends AbstractSystemMetricsPublisher {
     Set<TimelineMetric> entityMetrics = new HashSet<TimelineMetric>();
 
     entityMetrics.add(getTimelineMetric(
-        ApplicationMetricsConstants.APP_CPU_METRICS, timestamp,
-        appMetrics.getVcoreSeconds()));
+        ApplicationMetricsConstants.APP_GUARANTEED_CPU_METRICS, timestamp,
+        appMetrics.getGuaranteedVcoreSeconds()));
     entityMetrics.add(getTimelineMetric(
-        ApplicationMetricsConstants.APP_MEM_METRICS, timestamp,
-        appMetrics.getMemorySeconds()));
+        ApplicationMetricsConstants.APP_GUARANTEED_MEM_METRICS, timestamp,
+        appMetrics.getGuaranteedMemorySeconds()));
+    entityMetrics.add(getTimelineMetric(
+        ApplicationMetricsConstants.APP_OPPORTUNISTIC_CPU_METRICS,
+        timestamp, appMetrics.getOpportunisticVcoreSeconds()));
+    entityMetrics.add(getTimelineMetric(
+        ApplicationMetricsConstants.APP_OPPORTUNISTIC_MEM_METRICS,
+        timestamp, appMetrics.getOpportunisticMemorySeconds()));
     entityMetrics.add(getTimelineMetric(
             ApplicationMetricsConstants.APP_MEM_PREEMPT_METRICS, timestamp,
             appMetrics.getPreemptedMemorySeconds()));

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/recovery/RMStateStore.java

@@ -904,8 +904,9 @@ public abstract class RMStateStore extends AbstractService {
             appAttempt.getAppAttemptId(),
             appAttempt.getMasterContainer(),
             credentials, appAttempt.getStartTime(),
-            resUsage.getResourceUsageSecondsMap(),
-            attempMetrics.getPreemptedResourceSecondsMap());
+            resUsage.getGuaranteedResourceUsageSecondsMap(),
+            attempMetrics.getPreemptedResourceSecondsMap(),
+            resUsage.getOpportunisticResourceSecondsMap());
 
     getRMStateStoreEventHandler().handle(
       new RMStateStoreAppAttemptEvent(attemptState));

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/recovery/records/ApplicationAttemptStateData.java

@@ -19,6 +19,7 @@
 package org.apache.hadoop.yarn.server.resourcemanager.recovery.records;
 
 import org.apache.hadoop.classification.InterfaceAudience.Public;
+import org.apache.hadoop.classification.InterfaceAudience.Private;
 import org.apache.hadoop.classification.InterfaceStability.Unstable;
 import org.apache.hadoop.security.Credentials;
 import org.apache.hadoop.yarn.api.records.ApplicationAttemptId;
@@ -45,8 +46,9 @@ public abstract class ApplicationAttemptStateData {
       Credentials attemptTokens, long startTime, RMAppAttemptState finalState,
       String finalTrackingUrl, String diagnostics,
       FinalApplicationStatus amUnregisteredFinalStatus, int exitStatus,
-      long finishTime, Map<String, Long> resourceSecondsMap,
-      Map<String, Long> preemptedResourceSecondsMap) {
+      long finishTime, Map<String, Long> guaranteedResourceSecondsMap,
+      Map<String, Long> preemptedResourceSecondsMap,
+      Map<String, Long> opportunisticResourcesSecondsMap) {
     ApplicationAttemptStateData attemptStateData =
         Records.newRecord(ApplicationAttemptStateData.class);
     attemptStateData.setAttemptId(attemptId);
@@ -59,19 +61,22 @@ public abstract class ApplicationAttemptStateData {
     attemptStateData.setFinalApplicationStatus(amUnregisteredFinalStatus);
     attemptStateData.setAMContainerExitStatus(exitStatus);
     attemptStateData.setFinishTime(finishTime);
-    attemptStateData.setMemorySeconds(RMServerUtils
-        .getOrDefault(resourceSecondsMap,
+    attemptStateData.setGuaranteedMemorySeconds(RMServerUtils
+        .getOrDefault(guaranteedResourceSecondsMap,
             ResourceInformation.MEMORY_MB.getName(), 0L));
-    attemptStateData.setVcoreSeconds(RMServerUtils
-        .getOrDefault(resourceSecondsMap, ResourceInformation.VCORES.getName(),
-            0L));
+    attemptStateData.setGuaranteedVcoreSeconds(RMServerUtils
+        .getOrDefault(guaranteedResourceSecondsMap,
+            ResourceInformation.VCORES.getName(), 0L));
     attemptStateData.setPreemptedMemorySeconds(RMServerUtils
         .getOrDefault(preemptedResourceSecondsMap,
             ResourceInformation.MEMORY_MB.getName(), 0L));
     attemptStateData.setPreemptedVcoreSeconds(RMServerUtils
         .getOrDefault(preemptedResourceSecondsMap,
             ResourceInformation.VCORES.getName(), 0L));
-    attemptStateData.setResourceSecondsMap(resourceSecondsMap);
+    attemptStateData.setGuaranteedResourceSecondsMap(
+        guaranteedResourceSecondsMap);
+    attemptStateData.setOpportunisticResourceSecondsMap(
+        opportunisticResourcesSecondsMap);
     attemptStateData
         .setPreemptedResourceSecondsMap(preemptedResourceSecondsMap);
     return attemptStateData;
@@ -80,11 +85,13 @@ public abstract class ApplicationAttemptStateData {
   public static ApplicationAttemptStateData newInstance(
       ApplicationAttemptId attemptId, Container masterContainer,
       Credentials attemptTokens, long startTime,
-      Map<String, Long> resourceSeondsMap,
-      Map<String, Long> preemptedResourceSecondsMap) {
+      Map<String, Long> guaranteedResourceSecondsMap,
+      Map<String, Long> preemptedResourceSecondsMap,
+      Map<String, Long> opportunisticResourcesSecondsMap) {
     return newInstance(attemptId, masterContainer, attemptTokens, startTime,
         null, "N/A", "", null, ContainerExitStatus.INVALID, 0,
-        resourceSeondsMap, preemptedResourceSecondsMap);
+        guaranteedResourceSecondsMap, preemptedResourceSecondsMap,
+        opportunisticResourcesSecondsMap);
   }
 
 
@@ -180,29 +187,77 @@ public abstract class ApplicationAttemptStateData {
   public abstract void setFinishTime(long finishTime);
 
   /**
-  * Get the <em>memory seconds</em> (in MB seconds) of the application.
-   * @return <em>memory seconds</em> (in MB seconds) of the application
+   * Get the <em>guaranteed memory seconds</em> (in MB seconds) of the
+   * application.
+   * @return <em>guaranteed memory seconds</em> (in MB seconds) of the
+   *          application
    */
   @Public
   @Unstable
+  @Deprecated
   public abstract long getMemorySeconds();
 
   @Public
   @Unstable
+  @Deprecated
   public abstract void setMemorySeconds(long memorySeconds);
 
   /**
-   * Get the <em>vcore seconds</em> of the application.
-   * @return <em>vcore seconds</em> of the application
+   * Get the <em>guaranteed vcore seconds</em> of the application.
+   * @return <em>guaranteed vcore seconds</em> of the application
    */
   @Public
   @Unstable
+  @Deprecated
   public abstract long getVcoreSeconds();
 
   @Public
   @Unstable
+  @Deprecated
   public abstract void setVcoreSeconds(long vcoreSeconds);
 
+  /**
+   * Get the <em>guaranteed memory seconds</em> (in MB seconds) of the
+   * application.
+   * @return <em>guaranteed memory seconds</em> (in MB seconds) of the
+   *         application
+   */
+  @Public
+  @Unstable
+  public abstract long getGuaranteedMemorySeconds();
+
+  @Private
+  public abstract void setGuaranteedMemorySeconds(long memorySeconds);
+
+  /**
+   * Get the <em>guaranteed vcore seconds</em> of the application.
+   * @return <em>guaranteed vcore seconds</em> of the application
+   */
+  @Public
+  @Unstable
+  public abstract long getGuaranteedVcoreSeconds();
+
+  @Private
+  public abstract void setGuaranteedVcoreSeconds(long vcoreSeconds);
+
+  /**
+   * Get the <em>opportunistic memory seconds</em> (in MB seconds) of the
+   * application.
+   * @return <em>opportunistic memory seconds</em> (in MB seconds) of the
+   *         application
+   */
+  @Public
+  @Unstable
+  public abstract long getOpportunisticMemorySeconds();
+
+  /**
+   * Get the <em>opportunistic vcore seconds</em> of the application.
+   * @return <em>opportunistic vcore seconds</em> of the application
+   */
+  @Public
+  @Unstable
+  public abstract long getOpportunisticVcoreSeconds();
+
   /**
    * Get the <em>preempted memory seconds</em>
    * (in MB seconds) of the application.
@@ -232,28 +287,54 @@ public abstract class ApplicationAttemptStateData {
   public abstract void setPreemptedVcoreSeconds(long vcoreSeconds);
 
   /**
-   * Get the aggregated number of resources preempted that the application has
+   * Get the aggregated number of guaranteed resources that the application has
    * allocated times the number of seconds the application has been running.
    *
-   * @return map containing the resource name and aggregated preempted
-   * resource-seconds
+   * @return map containing the resource name and aggregated guaranteed
+   *         resource-seconds
    */
   @Public
   @Unstable
+  @Deprecated
   public abstract Map<String, Long> getResourceSecondsMap();
 
   /**
-   * Set the aggregated number of resources that the application has
+   * Set the aggregated number of guaranteed resources that the application has
    * allocated times the number of seconds the application has been running.
    *
    * @param resourceSecondsMap map containing the resource name and aggregated
-   *                           resource-seconds
+   *                           guaranteed resource-seconds
    */
   @Public
   @Unstable
+  @Deprecated
   public abstract void setResourceSecondsMap(
       Map<String, Long> resourceSecondsMap);
 
+
+  /**
+   * Get the aggregated number of guaranteed resources that the application has
+   * allocated times the number of seconds the application has been running.
+   *
+   * @return map containing the resource name and aggregated guaranteed
+   *         resource-seconds
+   */
+  @Public
+  @Unstable
+  public abstract Map<String, Long> getGuaranteedResourceSecondsMap();
+
+  /**
+   * Set the aggregated number of guaranteed resources that the application has
+   * allocated times the number of seconds the application has been running.
+   *
+   * @param resourceSecondsMap map containing the resource name and aggregated
+   *                           guaranteed resource-seconds
+   */
+  @Public
+  @Unstable
+  public abstract void setGuaranteedResourceSecondsMap(
+      Map<String, Long> resourceSecondsMap);
+
   /**
    * Get the aggregated number of resources preempted that the application has
    * allocated times the number of seconds the application has been running.
@@ -276,4 +357,27 @@ public abstract class ApplicationAttemptStateData {
   @Unstable
   public abstract void setPreemptedResourceSecondsMap(
       Map<String, Long> preemptedResourceSecondsMap);
+
+  /**
+   * Get the aggregated number of opportunistic resources that the application
+   * has allocated times the number of seconds the application has been running.
+   *
+   * @return map containing the resource name and aggregated opportunistic
+   *         resource-seconds
+   */
+  @Public
+  @Unstable
+  public abstract Map<String, Long> getOpportunisticResourceSecondsMap();
+
+  /**
+   * Set the aggregated number of opportunistic resources that the application
+   * has allocated times the number of seconds the application has been running.
+   *
+   * @param resourceSecondsMap map containing the resource name and aggregated
+   *                           opportunistic resource-seconds
+   */
+  @Public
+  @Unstable
+  public abstract void setOpportunisticResourceSecondsMap(
+      Map<String, Long> resourceSecondsMap);
 }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/recovery/records/impl/pb/ApplicationAttemptStateDataPBImpl.java

@@ -31,6 +31,7 @@ import org.apache.hadoop.security.Credentials;
 import org.apache.hadoop.yarn.api.records.ApplicationAttemptId;
 import org.apache.hadoop.yarn.api.records.Container;
 import org.apache.hadoop.yarn.api.records.FinalApplicationStatus;
+import org.apache.hadoop.yarn.api.records.ResourceInformation;
 import org.apache.hadoop.yarn.api.records.impl.pb.ApplicationAttemptIdPBImpl;
 import org.apache.hadoop.yarn.api.records.impl.pb.ContainerPBImpl;
 import org.apache.hadoop.yarn.api.records.impl.pb.ProtoUtils;
@@ -56,8 +57,9 @@ public class ApplicationAttemptStateDataPBImpl extends
   private Container masterContainer = null;
   private ByteBuffer appAttemptTokens = null;
 
-  private Map<String, Long> resourceSecondsMap;
+  private Map<String, Long> guaranteedResourceSecondsMap;
   private Map<String, Long> preemptedResourceSecondsMap;
+  private Map<String, Long> opportunisticResourceSecondsMap;
 
   public ApplicationAttemptStateDataPBImpl() {
     builder = ApplicationAttemptStateDataProto.newBuilder();
@@ -243,29 +245,71 @@ public class ApplicationAttemptStateDataPBImpl extends
   }
 
   @Override
+  @Deprecated
   public long getMemorySeconds() {
-    ApplicationAttemptStateDataProtoOrBuilder p = viaProto ? proto : builder;
-    return p.getMemorySeconds();
+    return getGuaranteedMemorySeconds();
   }
  
   @Override
+  @Deprecated
   public long getVcoreSeconds() {
-    ApplicationAttemptStateDataProtoOrBuilder p = viaProto ? proto : builder;
-    return p.getVcoreSeconds();
+    return getGuaranteedVcoreSeconds();
   }
 
   @Override
+  @Deprecated
   public void setMemorySeconds(long memorySeconds) {
-    maybeInitBuilder();
-    builder.setMemorySeconds(memorySeconds);
+    setGuaranteedMemorySeconds(memorySeconds);
   }
  
   @Override
+  @Deprecated
   public void setVcoreSeconds(long vcoreSeconds) {
+    setGuaranteedVcoreSeconds(vcoreSeconds);
+  }
+
+  @Override
+  public long getGuaranteedMemorySeconds() {
+    ApplicationAttemptStateDataProtoOrBuilder p = viaProto ? proto : builder;
+    return p.getMemorySeconds();
+  }
+
+  @Override
+  public void setGuaranteedMemorySeconds(long memorySeconds) {
+    maybeInitBuilder();
+    builder.setMemorySeconds(memorySeconds);
+  }
+
+  @Override
+  public long getGuaranteedVcoreSeconds() {
+    ApplicationAttemptStateDataProtoOrBuilder p = viaProto ? proto : builder;
+    return p.getVcoreSeconds();
+  }
+
+  @Override
+  public void setGuaranteedVcoreSeconds(long vcoreSeconds) {
     maybeInitBuilder();
     builder.setVcoreSeconds(vcoreSeconds);
   }
 
+  @Override
+  public long getOpportunisticMemorySeconds() {
+    Map<String, Long> tmp = getOpportunisticResourceSecondsMap();
+    if (tmp.containsKey(ResourceInformation.MEMORY_MB.getName())) {
+      return tmp.get(ResourceInformation.MEMORY_MB.getName());
+    }
+    return 0;
+  }
+
+  @Override
+  public long getOpportunisticVcoreSeconds() {
+    Map<String, Long> tmp = getOpportunisticResourceSecondsMap();
+    if (tmp.containsKey(ResourceInformation.VCORES.getName())) {
+      return tmp.get(ResourceInformation.VCORES.getName());
+    }
+    return 0;
+  }
+
   @Override
   public long getPreemptedMemorySeconds() {
     ApplicationAttemptStateDataProtoOrBuilder p = viaProto ? proto : builder;
@@ -410,21 +454,35 @@ public class ApplicationAttemptStateDataPBImpl extends
   }
 
   @Override
+  @Deprecated
   public Map<String, Long> getResourceSecondsMap() {
-    if (this.resourceSecondsMap != null) {
-      return this.resourceSecondsMap;
+    return getGuaranteedResourceSecondsMap();
+  }
+
+  @Override
+  @Deprecated
+  public void setResourceSecondsMap(Map<String, Long> resourceSecondsMap) {
+    setGuaranteedResourceSecondsMap(resourceSecondsMap);
+  }
+
+  @Override
+  public Map<String, Long> getGuaranteedResourceSecondsMap() {
+    if (this.guaranteedResourceSecondsMap != null) {
+      return this.guaranteedResourceSecondsMap;
     }
     ApplicationAttemptStateDataProtoOrBuilder p = viaProto ? proto : builder;
-    this.resourceSecondsMap = ProtoUtils.convertStringLongMapProtoListToMap(
-        p.getApplicationResourceUsageMapList());
-    return this.resourceSecondsMap;
+    this.guaranteedResourceSecondsMap =
+        ProtoUtils.convertStringLongMapProtoListToMap(
+            p.getApplicationResourceUsageMapList());
+    return this.guaranteedResourceSecondsMap;
   }
 
   @Override
-  public void setResourceSecondsMap(Map<String, Long> resourceSecondsMap) {
+  public void setGuaranteedResourceSecondsMap(
+      Map<String, Long> resourceSecondsMap) {
     maybeInitBuilder();
     builder.clearApplicationResourceUsageMap();
-    this.resourceSecondsMap = resourceSecondsMap;
+    this.guaranteedResourceSecondsMap = resourceSecondsMap;
     if (resourceSecondsMap != null) {
       builder.addAllApplicationResourceUsageMap(
           ProtoUtils.convertMapToStringLongMapProtoList(resourceSecondsMap));
@@ -454,4 +512,28 @@ public class ApplicationAttemptStateDataPBImpl extends
           .convertMapToStringLongMapProtoList(preemptedResourceSecondsMap));
     }
   }
+
+  @Override
+  public Map<String, Long> getOpportunisticResourceSecondsMap() {
+    if (this.opportunisticResourceSecondsMap != null) {
+      return this.opportunisticResourceSecondsMap;
+    }
+    ApplicationAttemptStateDataProtoOrBuilder p = viaProto ? proto : builder;
+    this.opportunisticResourceSecondsMap =
+        ProtoUtils.convertStringLongMapProtoListToMap(
+            p.getApplicationOpportunisticResourceUsageMapList());
+    return this.opportunisticResourceSecondsMap;
+  }
+
+  @Override
+  public void setOpportunisticResourceSecondsMap(
+      Map<String, Long> resourceSecondsMap) {
+    maybeInitBuilder();
+    builder.clearApplicationOpportunisticResourceUsageMap();
+    this.opportunisticResourceSecondsMap = resourceSecondsMap;
+    if (resourceSecondsMap != null) {
+      builder.addAllApplicationOpportunisticResourceUsageMap(
+          ProtoUtils.convertMapToStringLongMapProtoList(resourceSecondsMap));
+    }
+  }
 }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/rmapp/RMAppImpl.java

@@ -456,6 +456,7 @@ public class RMAppImpl implements RMApp, Recoverable {
     } else {
       this.startTime = startTime;
     }
+    LOG.info(applicationId.toString() + " started at " + this.startTime);
     this.applicationType = StringInterner.weakIntern(applicationType);
     this.applicationTags = applicationTags;
     this.amReqs = amReqs;
@@ -775,10 +776,12 @@ public class RMAppImpl implements RMApp, Recoverable {
         }
 
         RMAppMetrics rmAppMetrics = getRMAppMetrics();
-        appUsageReport
-            .setResourceSecondsMap(rmAppMetrics.getResourceSecondsMap());
+        appUsageReport.setGuaranteedResourceSecondsMap(
+            rmAppMetrics.getGuaranteedResourceSecondsMap());
         appUsageReport.setPreemptedResourceSecondsMap(
             rmAppMetrics.getPreemptedResourceSecondsMap());
+        appUsageReport.setOpportunisticResourceSecondsMap(
+            rmAppMetrics.getOpportunisticResourceSecondsMap());
       }
 
       if (currentApplicationAttemptId == null) {
@@ -1705,8 +1708,9 @@ public class RMAppImpl implements RMApp, Recoverable {
     Resource resourcePreempted = Resource.newInstance(0, 0);
     int numAMContainerPreempted = 0;
     int numNonAMContainerPreempted = 0;
-    Map<String, Long> resourceSecondsMap = new HashMap<>();
-    Map<String, Long> preemptedSecondsMap = new HashMap<>();
+    Map<String, Long> guaranteedResourceSecondsMap = new HashMap<>(2);
+    Map<String, Long> preemptedSecondsMap = new HashMap<>(2);
+    Map<String, Long> opportunsiticResourceSecondsMap = new HashMap<>(2);
     this.readLock.lock();
     try {
       for (RMAppAttempt attempt : attempts.values()) {
@@ -1722,20 +1726,15 @@ public class RMAppImpl implements RMApp, Recoverable {
           // for both running and finished containers.
           AggregateAppResourceUsage resUsage =
               attempt.getRMAppAttemptMetrics().getAggregateAppResourceUsage();
-          for (Map.Entry<String, Long> entry : resUsage
-              .getResourceUsageSecondsMap().entrySet()) {
-            long value = RMServerUtils
-                .getOrDefault(resourceSecondsMap, entry.getKey(), 0L);
-            value += entry.getValue();
-            resourceSecondsMap.put(entry.getKey(), value);
-          }
-          for (Map.Entry<String, Long> entry : attemptMetrics
-              .getPreemptedResourceSecondsMap().entrySet()) {
-            long value = RMServerUtils
-                .getOrDefault(preemptedSecondsMap, entry.getKey(), 0L);
-            value += entry.getValue();
-            preemptedSecondsMap.put(entry.getKey(), value);
-          }
+          Resources.mergeResourceSecondsMap(
+              resUsage.getGuaranteedResourceUsageSecondsMap(),
+              guaranteedResourceSecondsMap);
+          Resources.mergeResourceSecondsMap(
+              resUsage.getOpportunisticResourceSecondsMap(),
+              opportunsiticResourceSecondsMap);
+          Resources.mergeResourceSecondsMap(
+              attemptMetrics.getPreemptedResourceSecondsMap(),
+              preemptedSecondsMap);
         }
       }
     } finally {
@@ -1743,7 +1742,8 @@ public class RMAppImpl implements RMApp, Recoverable {
     }
 
     return new RMAppMetrics(resourcePreempted, numNonAMContainerPreempted,
-        numAMContainerPreempted, resourceSecondsMap, preemptedSecondsMap);
+        numAMContainerPreempted, guaranteedResourceSecondsMap,
+        preemptedSecondsMap, opportunsiticResourceSecondsMap);
   }
 
   @Private

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/rmapp/RMAppMetrics.java

@@ -28,18 +28,21 @@ public class RMAppMetrics {
   final Resource resourcePreempted;
   final int numNonAMContainersPreempted;
   final int numAMContainersPreempted;
-  private final Map<String, Long> resourceSecondsMap;
+  private final Map<String, Long> guaranteedResourceSecondsMap;
   private final Map<String, Long> preemptedResourceSecondsMap;
+  private final Map<String, Long> opportunisticResourceSecondsMap;
 
   public RMAppMetrics(Resource resourcePreempted,
       int numNonAMContainersPreempted, int numAMContainersPreempted,
-      Map<String, Long> resourceSecondsMap,
-      Map<String, Long> preemptedResourceSecondsMap) {
+      Map<String, Long> guaranteedResourceSecondsMap,
+      Map<String, Long> preemptedResourceSecondsMap,
+      Map<String, Long> opportunisticResourceSecondsMap) {
     this.resourcePreempted = resourcePreempted;
     this.numNonAMContainersPreempted = numNonAMContainersPreempted;
     this.numAMContainersPreempted = numAMContainersPreempted;
-    this.resourceSecondsMap = resourceSecondsMap;
+    this.guaranteedResourceSecondsMap = guaranteedResourceSecondsMap;
     this.preemptedResourceSecondsMap = preemptedResourceSecondsMap;
+    this.opportunisticResourceSecondsMap = opportunisticResourceSecondsMap;
   }
 
   public Resource getResourcePreempted() {
@@ -54,17 +57,25 @@ public class RMAppMetrics {
     return numAMContainersPreempted;
   }
 
-  public long getMemorySeconds() {
-    return RMServerUtils.getOrDefault(resourceSecondsMap,
+  public long getGuaranteedMemorySeconds() {
+    return RMServerUtils.getOrDefault(guaranteedResourceSecondsMap,
         ResourceInformation.MEMORY_MB.getName(), 0L);
   }
 
-  public long getVcoreSeconds() {
-    return RMServerUtils
-        .getOrDefault(resourceSecondsMap, ResourceInformation.VCORES.getName(),
-            0L);
+  public long getGuaranteedVcoreSeconds() {
+    return RMServerUtils.getOrDefault(guaranteedResourceSecondsMap,
+        ResourceInformation.VCORES.getName(), 0L);
+  }
+
+  public long getOpportunisticMemorySeconds() {
+    return RMServerUtils.getOrDefault(opportunisticResourceSecondsMap,
+        ResourceInformation.MEMORY_MB.getName(), 0L);
   }
 
+  public long getOpportunisticVcoreSeconds() {
+    return RMServerUtils.getOrDefault(opportunisticResourceSecondsMap,
+        ResourceInformation.VCORES.getName(), 0L);
+  }
   public long getPreemptedMemorySeconds() {
     return RMServerUtils.getOrDefault(preemptedResourceSecondsMap,
         ResourceInformation.MEMORY_MB.getName(), 0L);
@@ -75,12 +86,15 @@ public class RMAppMetrics {
         ResourceInformation.VCORES.getName(), 0L);
   }
 
-  public Map<String, Long> getResourceSecondsMap() {
-    return resourceSecondsMap;
+  public Map<String, Long> getGuaranteedResourceSecondsMap() {
+    return guaranteedResourceSecondsMap;
   }
 
   public Map<String, Long> getPreemptedResourceSecondsMap() {
     return preemptedResourceSecondsMap;
   }
 
+  public Map<String, Long> getOpportunisticResourceSecondsMap() {
+    return opportunisticResourceSecondsMap;
+  }
 }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/rmapp/attempt/AggregateAppResourceUsage.java

@@ -27,30 +27,55 @@ import java.util.Map;
 
 @Private
 public class AggregateAppResourceUsage {
-  private Map<String, Long> resourceSecondsMap = new HashMap<>();
+  private Map<String, Long> guaranteedResourceSecondsMap = new HashMap<>();
+  private Map<String, Long> opportunisticResourceSecondsMap = new HashMap<>();
 
-  public AggregateAppResourceUsage(Map<String, Long> resourceSecondsMap) {
-    this.resourceSecondsMap.putAll(resourceSecondsMap);
+  public AggregateAppResourceUsage(
+      Map<String, Long> guaranteedResourceSecondsMap,
+      Map<String, Long> opportunisticResourceSecondsMap) {
+    this.guaranteedResourceSecondsMap.putAll(
+        guaranteedResourceSecondsMap);
+    this.opportunisticResourceSecondsMap.putAll(
+        opportunisticResourceSecondsMap);
   }
 
   /**
-   * @return the memorySeconds
+   * @return the guaranteed memory seconds
    */
-  public long getMemorySeconds() {
-    return RMServerUtils.getOrDefault(resourceSecondsMap,
+  public long getGuaranteedMemorySeconds() {
+    return RMServerUtils.getOrDefault(guaranteedResourceSecondsMap,
         ResourceInformation.MEMORY_MB.getName(), 0L);
   }
 
   /**
-   * @return the vcoreSeconds
+   * @return the guaranteed vcore seconds
    */
-  public long getVcoreSeconds() {
-    return RMServerUtils
-        .getOrDefault(resourceSecondsMap, ResourceInformation.VCORES.getName(),
-            0L);
+  public long getGuaranteedVcoreSeconds() {
+    return RMServerUtils.getOrDefault(guaranteedResourceSecondsMap,
+        ResourceInformation.VCORES.getName(), 0L);
   }
 
-  public Map<String, Long> getResourceUsageSecondsMap() {
-    return resourceSecondsMap;
+  /**
+   * @return the opportunistic memory seconds
+   */
+  public long getOpportunisticMemorySeconds() {
+    return RMServerUtils.getOrDefault(opportunisticResourceSecondsMap,
+        ResourceInformation.MEMORY_MB.getName(), 0L);
+  }
+
+  /**
+   * @return the opportunistic vcore seconds
+   */
+  public long getOpportunisticVcoreSeconds() {
+    return RMServerUtils.getOrDefault(opportunisticResourceSecondsMap,
+        ResourceInformation.VCORES.getName(), 0L);
+  }
+
+  public Map<String, Long> getGuaranteedResourceUsageSecondsMap() {
+    return guaranteedResourceSecondsMap;
+  }
+
+  public Map<String, Long> getOpportunisticResourceSecondsMap() {
+    return opportunisticResourceSecondsMap;
   }
 }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/rmapp/attempt/RMAppAttemptImpl.java

@@ -938,15 +938,18 @@ public class RMAppAttemptImpl implements RMAppAttempt, Recoverable {
     this.readLock.lock();
     try {
       ApplicationResourceUsageReport report =
-          scheduler.getAppResourceUsageReport(this.getAppAttemptId());
+          scheduler.getAppActiveResourceUsageReport(this.getAppAttemptId());
       if (report == null) {
         report = RMServerUtils.DUMMY_APPLICATION_RESOURCE_USAGE_REPORT;
       }
       AggregateAppResourceUsage resUsage =
           this.attemptMetrics.getAggregateAppResourceUsage();
-      report.setResourceSecondsMap(resUsage.getResourceUsageSecondsMap());
+      report.setGuaranteedResourceSecondsMap(
+          resUsage.getGuaranteedResourceUsageSecondsMap());
       report.setPreemptedResourceSecondsMap(
           this.attemptMetrics.getPreemptedResourceSecondsMap());
+      report.setOpportunisticResourceSecondsMap(
+          resUsage.getOpportunisticResourceSecondsMap());
       return report;
     } finally {
       this.readLock.unlock();
@@ -983,10 +986,12 @@ public class RMAppAttemptImpl implements RMAppAttempt, Recoverable {
     this.finalStatus = attemptState.getFinalApplicationStatus();
     this.startTime = attemptState.getStartTime();
     this.finishTime = attemptState.getFinishTime();
-    this.attemptMetrics
-        .updateAggregateAppResourceUsage(attemptState.getResourceSecondsMap());
+    this.attemptMetrics.updateAggregateAppGuaranteedResourceUsage(
+        attemptState.getGuaranteedResourceSecondsMap());
     this.attemptMetrics.updateAggregatePreemptedAppResourceUsage(
         attemptState.getPreemptedResourceSecondsMap());
+    this.attemptMetrics.updateAggregateAppOpportunisticResourceUsage(
+        attemptState.getOpportunisticResourceSecondsMap());
   }
 
   public void transferStateFromAttempt(RMAppAttempt attempt) {
@@ -1406,9 +1411,11 @@ public class RMAppAttemptImpl implements RMAppAttempt, Recoverable {
     ApplicationAttemptStateData attemptState = ApplicationAttemptStateData
         .newInstance(applicationAttemptId, getMasterContainer(),
             rmStore.getCredentialsFromAppAttempt(this), startTime,
-            stateToBeStored, finalTrackingUrl, diags.toString(), finalStatus, exitStatus,
-            getFinishTime(), resUsage.getResourceUsageSecondsMap(),
-            this.attemptMetrics.getPreemptedResourceSecondsMap());
+            stateToBeStored, finalTrackingUrl, diags.toString(), finalStatus,
+            exitStatus, getFinishTime(),
+            resUsage.getGuaranteedResourceUsageSecondsMap(),
+            this.attemptMetrics.getPreemptedResourceSecondsMap(),
+            resUsage.getOpportunisticResourceSecondsMap());
     LOG.info("Updating application attempt " + applicationAttemptId
         + " with final state: " + targetedFinalState + ", and exit status: "
         + exitStatus);
@@ -1837,8 +1844,10 @@ public class RMAppAttemptImpl implements RMAppAttempt, Recoverable {
                 newTrackingUrl, appAttempt.getDiagnostics(), null,
                 ContainerExitStatus.INVALID, appAttempt.getFinishTime(),
                 appAttempt.attemptMetrics.getAggregateAppResourceUsage()
-                    .getResourceUsageSecondsMap(),
-                appAttempt.attemptMetrics.getPreemptedResourceSecondsMap());
+                    .getGuaranteedResourceUsageSecondsMap(),
+                appAttempt.attemptMetrics.getPreemptedResourceSecondsMap(),
+                appAttempt.attemptMetrics.getAggregateAppResourceUsage()
+                    .getOpportunisticResourceSecondsMap());
         appAttempt.rmContext.getStateStore()
             .updateApplicationAttemptState(attemptState);
       }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/rmapp/attempt/RMAppAttemptMetrics.java

@@ -54,8 +54,11 @@ public class RMAppAttemptMetrics {
   
   private ReadLock readLock;
   private WriteLock writeLock;
-  private Map<String, AtomicLong> resourceUsageMap = new ConcurrentHashMap<>();
-  private Map<String, AtomicLong> preemptedResourceMap = new ConcurrentHashMap<>();
+  private Map<String, AtomicLong> guaranteedResourceUsageMap
+      = new HashMap<>();
+  private Map<String, AtomicLong> preemptedResourceMap = new HashMap<>();
+  private Map<String, AtomicLong> opportunisticResourceUsageMap
+      = new HashMap<>();
   private RMContext rmContext;
 
   private int[][] localityStatistics =
@@ -130,8 +133,10 @@ public class RMAppAttemptMetrics {
   }
 
   public AggregateAppResourceUsage getAggregateAppResourceUsage() {
-    Map<String, Long> resourcesUsed =
-        convertAtomicLongMaptoLongMap(resourceUsageMap);
+    Map<String, Long> guaranteedResourcesUsed =
+        convertAtomicLongMaptoLongMap(guaranteedResourceUsageMap);
+    Map<String, Long> opportunisticResourcesUsed =
+        convertAtomicLongMaptoLongMap(opportunisticResourceUsageMap);
 
     // Only add in the running containers if this is the active attempt.
     RMApp rmApp = rmContext.getRMApps().get(attemptId.getApplicationId());
@@ -140,27 +145,25 @@ public class RMAppAttemptMetrics {
       if (currentAttempt != null
           && currentAttempt.getAppAttemptId().equals(attemptId)) {
         ApplicationResourceUsageReport appResUsageReport =
-            rmContext.getScheduler().getAppResourceUsageReport(attemptId);
+            rmContext.getScheduler().getAppActiveResourceUsageReport(attemptId);
         if (appResUsageReport != null) {
-          Map<String, Long> tmp = appResUsageReport.getResourceSecondsMap();
-          for (Map.Entry<String, Long> entry : tmp.entrySet()) {
-            Long value = resourcesUsed.get(entry.getKey());
-            if (value != null) {
-              value += entry.getValue();
-            } else {
-              value = entry.getValue();
-            }
-            resourcesUsed.put(entry.getKey(), value);
-          }
+          Resources.mergeResourceSecondsMap(
+              appResUsageReport.getGuaranteedResourceSecondsMap(),
+              guaranteedResourcesUsed);
+          Resources.mergeResourceSecondsMap(
+              appResUsageReport.getOpportunisticResourceSecondsMap(),
+              opportunisticResourcesUsed);
         }
       }
     }
-    return new AggregateAppResourceUsage(resourcesUsed);
+
+    return new AggregateAppResourceUsage(guaranteedResourcesUsed,
+        opportunisticResourcesUsed);
   }
 
   public void updateAggregateAppResourceUsage(Resource allocated,
       long deltaUsedMillis) {
-    updateUsageMap(allocated, deltaUsedMillis, resourceUsageMap);
+    updateUsageMap(allocated, deltaUsedMillis, guaranteedResourceUsageMap);
   }
 
   public void updateAggregatePreemptedAppResourceUsage(Resource allocated,
@@ -168,9 +171,14 @@ public class RMAppAttemptMetrics {
     updateUsageMap(allocated, deltaUsedMillis, preemptedResourceMap);
   }
 
-  public void updateAggregateAppResourceUsage(
+  public void updateAggregateAppGuaranteedResourceUsage(
       Map<String, Long> resourceSecondsMap) {
-    updateUsageMap(resourceSecondsMap, resourceUsageMap);
+    updateUsageMap(resourceSecondsMap, guaranteedResourceUsageMap);
+  }
+
+  public void updateAggregateAppOpportunisticResourceUsage(
+      Map<String, Long> resourceSecondsMap) {
+    updateUsageMap(resourceSecondsMap, opportunisticResourceUsageMap);
   }
 
   public void updateAggregatePreemptedAppResourceUsage(
@@ -200,10 +208,9 @@ public class RMAppAttemptMetrics {
       if (!targetMap.containsKey(entry.getKey())) {
         resourceUsed = new AtomicLong(0);
         targetMap.put(entry.getKey(), resourceUsed);
-
       }
       resourceUsed = targetMap.get(entry.getKey());
-      resourceUsed.set(entry.getValue());
+      resourceUsed.addAndGet(entry.getValue());
     }
   }
 

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/rmcontainer/ContainerResourceUsageReport.java

@@ -0,0 +1,46 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.yarn.server.resourcemanager.rmcontainer;
+
+import org.apache.hadoop.classification.InterfaceAudience.Private;
+
+import java.util.Map;
+
+/**
+ * The resource usage information of a <code>Container</code>.
+ */
+@Private
+public class ContainerResourceUsageReport {
+  private final Map<String, Long> guaranteedResourceSecondsMap;
+  private final Map<String, Long> opportunisticResourceSecondsMap;
+
+  public ContainerResourceUsageReport(
+      Map<String, Long> guaranteedResourceSecondsMap,
+      Map<String, Long> opportunisticResourceSecondsMap) {
+    this.guaranteedResourceSecondsMap = guaranteedResourceSecondsMap;
+    this.opportunisticResourceSecondsMap = opportunisticResourceSecondsMap;
+  }
+
+  public Map<String, Long> getGuaranteedResourceUsageSecondsMap() {
+    return guaranteedResourceSecondsMap;
+  }
+
+  public Map<String, Long> getOpportunisticResourceSecondsMap() {
+    return opportunisticResourceSecondsMap;
+  }
+}

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/rmcontainer/RMContainer.java

@@ -87,7 +87,9 @@ public interface RMContainer extends EventHandler<RMContainerEvent>,
   ContainerState getContainerState();
   
   ContainerReport createContainerReport();
-  
+
+  ContainerResourceUsageReport getResourceUsageReport();
+
   boolean isAMContainer();
 
   ContainerRequest getContainerRequest();

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/rmcontainer/RMContainerImpl.java

@@ -21,6 +21,8 @@ package org.apache.hadoop.yarn.server.resourcemanager.rmcontainer;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.Set;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
@@ -39,6 +41,7 @@ import org.apache.hadoop.yarn.api.records.ExecutionType;
 import org.apache.hadoop.yarn.api.records.NodeId;
 import org.apache.hadoop.yarn.api.records.Priority;
 import org.apache.hadoop.yarn.api.records.Resource;
+import org.apache.hadoop.yarn.api.records.ResourceInformation;
 import org.apache.hadoop.yarn.conf.YarnConfiguration;
 import org.apache.hadoop.yarn.event.EventHandler;
 import org.apache.hadoop.yarn.server.api.protocolrecords.NMContainerStatus;
@@ -176,7 +179,7 @@ public class RMContainerImpl implements RMContainer {
   private NodeId reservedNode;
   private SchedulerRequestKey reservedSchedulerKey;
   private long creationTime;
-  private long finishTime;
+  private long finishTime = -1L;
   private ContainerStatus finishedStatus;
   private boolean isAMContainer;
   private ContainerRequest containerRequestForRecovery;
@@ -191,6 +194,10 @@ public class RMContainerImpl implements RMContainer {
 
   private volatile Set<String> allocationTags = null;
 
+  // This is updated whenever the container instance is updated in
+  // the case of container increase/decrease/promotion/demotion
+  private long lastContainerUpdateTime;
+
   public RMContainerImpl(Container container, SchedulerRequestKey schedulerKey,
       ApplicationAttemptId appAttemptId, NodeId nodeId, String user,
       RMContext rmContext) {
@@ -232,6 +239,7 @@ public class RMContainerImpl implements RMContainer {
     this.appAttemptId = appAttemptId;
     this.user = user;
     this.creationTime = creationTime;
+    this.lastContainerUpdateTime = creationTime;
     this.rmContext = rmContext;
     this.eventHandler = rmContext.getDispatcher().getEventHandler();
     this.containerAllocationExpirer = rmContext.getContainerAllocationExpirer();
@@ -272,9 +280,87 @@ public class RMContainerImpl implements RMContainer {
   }
 
   public void setContainer(Container container) {
+    // containers are updated by resetting the underlying Container instance,
+    // always update RMContainer resource usage before the update.
+    updateAppAttemptMetrics(true);
     this.container = container;
   }
 
+  /**
+   * Collect the resource usage information of the current underlying Container
+   * instance and update its RMAppAttemptMetrics. This is called whenever the
+   * RMContainer is updated (by updating its underlying container) or finishes.
+   * @param containerUpdated if it is called upon container update event
+   */
+  private void updateAppAttemptMetrics(boolean containerUpdated) {
+    RMAppAttempt rmAttempt = rmContext.getRMApps()
+        .get(getApplicationAttemptId().getApplicationId())
+        .getCurrentAppAttempt();
+
+    if (rmAttempt != null) {
+      // collect resource usage information of the current Container instance
+      ContainerResourceUsageReport resourceUsage =
+          getCurrentContainerResourceUsage(containerUpdated);
+
+      // If this is a preempted container, update preemption metrics
+      if (finishedStatus != null &&
+          ContainerExitStatus.PREEMPTED == finishedStatus.getExitStatus()) {
+        rmAttempt.getRMAppAttemptMetrics()
+            .updatePreemptionInfo(container.getResource(), this);
+        rmAttempt.getRMAppAttemptMetrics()
+            .updateAggregateAppOpportunisticResourceUsage(
+                resourceUsage.getGuaranteedResourceUsageSecondsMap());
+      }
+      rmAttempt.getRMAppAttemptMetrics()
+          .updateAggregateAppOpportunisticResourceUsage(
+              resourceUsage.getOpportunisticResourceSecondsMap());
+      rmAttempt.getRMAppAttemptMetrics()
+          .updateAggregateAppGuaranteedResourceUsage(
+              resourceUsage.getGuaranteedResourceUsageSecondsMap());
+    }
+  }
+
+  /**
+   * Get resource usage of the current underlying Container instance.
+   * @param containerUpdated if this is called upon container update
+   * @return resource usage of the current <code>container</code>
+   */
+  private ContainerResourceUsageReport getCurrentContainerResourceUsage(
+      boolean containerUpdated) {
+    ContainerResourceUsageReport report;
+
+    // A container generates usage until it finishes which is indicated
+    // by a positive finish timestamp that is set once it finishes
+    final long currentTimeMillis =
+        finishTime < 0 ? System.currentTimeMillis() : finishTime;
+    final long usedSeconds = (currentTimeMillis -
+        lastContainerUpdateTime) / 1000;
+    Resource resource = container.getResource();
+
+    if (container.getExecutionType() == ExecutionType.GUARANTEED) {
+      Map<String, Long> guaranteedResourceSeconds = new HashMap<>(2);
+      for (ResourceInformation entry : resource.getResources()) {
+        guaranteedResourceSeconds.put(
+            entry.getName(), entry.getValue() * usedSeconds);
+      }
+      report = new ContainerResourceUsageReport(guaranteedResourceSeconds,
+          Collections.emptyMap());
+    } else {
+      Map<String, Long> opportunisticResourceSeconds = new HashMap<>(2);
+      for (ResourceInformation entry : resource.getResources()) {
+        opportunisticResourceSeconds.put(
+            entry.getName(), entry.getValue() * usedSeconds);
+      }
+      report = new ContainerResourceUsageReport(Collections.emptyMap(),
+          opportunisticResourceSeconds);
+    }
+
+    if (containerUpdated) {
+      lastContainerUpdateTime = currentTimeMillis;
+    }
+    return report;
+  }
+
   @Override
   public RMContainerState getState() {
     this.readLock.lock();
@@ -704,7 +790,7 @@ public class RMContainerImpl implements RMContainer {
       // Inform AppAttempt
       // container.getContainer() can return null when a RMContainer is a
       // reserved container
-      updateAttemptMetrics(container);
+      container.updateAppAttemptMetrics(false);
 
       container.eventHandler.handle(new RMAppAttemptContainerFinishedEvent(
         container.appAttemptId, finishedEvent.getRemoteContainerStatus(),
@@ -721,28 +807,6 @@ public class RMContainerImpl implements RMContainer {
             container, container.finishTime);
       }
     }
-
-    private static void updateAttemptMetrics(RMContainerImpl container) {
-      Resource resource = container.getContainer().getResource();
-      RMApp app = container.rmContext.getRMApps()
-          .get(container.getApplicationAttemptId().getApplicationId());
-      if (app != null) {
-        RMAppAttempt rmAttempt = app.getCurrentAppAttempt();
-        if (rmAttempt != null) {
-          long usedMillis = container.finishTime - container.creationTime;
-          rmAttempt.getRMAppAttemptMetrics()
-              .updateAggregateAppResourceUsage(resource, usedMillis);
-          // If this is a preempted container, update preemption metrics
-          if (ContainerExitStatus.PREEMPTED == container.finishedStatus
-              .getExitStatus()) {
-            rmAttempt.getRMAppAttemptMetrics()
-                .updatePreemptionInfo(resource, container);
-            rmAttempt.getRMAppAttemptMetrics()
-                .updateAggregatePreemptedAppResourceUsage(resource, usedMillis);
-          }
-        }
-      }
-    }
   }
 
   private static boolean shouldPublishNonAMContainerEventstoATS(
@@ -803,6 +867,11 @@ public class RMContainerImpl implements RMContainer {
     return containerReport;
   }
 
+  @Override
+  public ContainerResourceUsageReport getResourceUsageReport() {
+    return getCurrentContainerResourceUsage(false);
+  }
+
   @Override
   public String getNodeHttpAddress() {
     try {

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/AbstractYarnScheduler.java

@@ -417,7 +417,7 @@ public abstract class AbstractYarnScheduler
   }
 
   @Override
-  public ApplicationResourceUsageReport getAppResourceUsageReport(
+  public ApplicationResourceUsageReport getAppActiveResourceUsageReport(
       ApplicationAttemptId appAttemptId) {
     SchedulerApplicationAttempt attempt = getApplicationAttempt(appAttemptId);
     if (attempt == null) {

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/SchedulerApplicationAttempt.java

@@ -61,12 +61,12 @@ import org.apache.hadoop.yarn.api.records.UpdateContainerError;
 import org.apache.hadoop.yarn.nodelabels.CommonNodeLabelsManager;
 import org.apache.hadoop.yarn.server.api.ContainerType;
 import org.apache.hadoop.yarn.server.resourcemanager.RMContext;
-import org.apache.hadoop.yarn.server.resourcemanager.RMServerUtils;
 import org.apache.hadoop.yarn.server.resourcemanager.nodelabels.RMNodeLabelsManager;
 import org.apache.hadoop.yarn.server.resourcemanager.rmapp.RMApp;
 import org.apache.hadoop.yarn.server.resourcemanager.rmapp.attempt.AggregateAppResourceUsage;
 import org.apache.hadoop.yarn.server.resourcemanager.rmapp.attempt.RMAppAttempt;
 import org.apache.hadoop.yarn.server.resourcemanager.rmapp.attempt.RMAppAttemptState;
+import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.ContainerResourceUsageReport;
 import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer;
 import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainerEvent;
 import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainerEventType;
@@ -108,7 +108,10 @@ public class SchedulerApplicationAttempt implements SchedulableEntity {
 
   private static final long MEM_AGGREGATE_ALLOCATION_CACHE_MSECS = 3000;
   protected long lastMemoryAggregateAllocationUpdateTime = 0;
-  private Map<String, Long> lastResourceSecondsMap = new HashMap<>();
+  private Map<String, Long> lastGuaranteedResourceSecondsMap =
+      new HashMap<>();
+  private Map<String, Long> lastOpportunisticResourceSecondsMap =
+      new HashMap<>();
   protected final AppSchedulingInfo appSchedulingInfo;
   protected ApplicationAttemptId attemptId;
   protected Map<ContainerId, RMContainer> liveContainers =
@@ -1083,34 +1086,47 @@ public class SchedulerApplicationAttempt implements SchedulableEntity {
     // recently.
     if ((currentTimeMillis - lastMemoryAggregateAllocationUpdateTime)
         > MEM_AGGREGATE_ALLOCATION_CACHE_MSECS) {
-      Map<String, Long> resourceSecondsMap = new HashMap<>();
+      Map<String, Long> aggregatedGuaranteedResourceSecondsMap =
+          new HashMap<>();
+      Map<String, Long> aggregatedOpportunisticResourceSecondsMap =
+          new HashMap<>();
       for (RMContainer rmContainer : this.liveContainers.values()) {
-        long usedMillis = currentTimeMillis - rmContainer.getCreationTime();
-        Resource resource = rmContainer.getContainer().getResource();
-        for (ResourceInformation entry : resource.getResources()) {
-          long value = RMServerUtils
-              .getOrDefault(resourceSecondsMap, entry.getName(), 0L);
-          value += entry.getValue() * usedMillis
-              / DateUtils.MILLIS_PER_SECOND;
-          resourceSecondsMap.put(entry.getName(), value);
-        }
+        ContainerResourceUsageReport containerResourceUsageReport =
+            rmContainer.getResourceUsageReport();
+        Resources.mergeResourceSecondsMap(
+            containerResourceUsageReport.getGuaranteedResourceUsageSecondsMap(),
+            aggregatedGuaranteedResourceSecondsMap);
+        Resources.mergeResourceSecondsMap(
+            containerResourceUsageReport.getOpportunisticResourceSecondsMap(),
+            aggregatedOpportunisticResourceSecondsMap);
       }
-
+      lastGuaranteedResourceSecondsMap =
+          aggregatedGuaranteedResourceSecondsMap;
+      lastOpportunisticResourceSecondsMap =
+          aggregatedOpportunisticResourceSecondsMap;
       lastMemoryAggregateAllocationUpdateTime = currentTimeMillis;
-      lastResourceSecondsMap = resourceSecondsMap;
     }
-    return new AggregateAppResourceUsage(lastResourceSecondsMap);
+    return new AggregateAppResourceUsage(lastGuaranteedResourceSecondsMap,
+        lastOpportunisticResourceSecondsMap);
   }
 
+  /**
+   * Get the resources that are actively being used by the app attempt.
+   * @return active resource usage
+   */
   public ApplicationResourceUsageReport getResourceUsageReport() {
     try {
       writeLock.lock();
       AggregateAppResourceUsage runningResourceUsage =
           getRunningAggregateAppResourceUsage();
-      Resource usedResourceClone = Resources.clone(
+      Resource guaranteedResourceUsedClone = Resources.clone(
           attemptResourceUsage.getAllUsed());
+      Resource opportunisticResourceUsedClone = Resources.clone(
+          attemptOpportunisticResourceUsage.getAllUsed());
       Resource reservedResourceClone = Resources.clone(
           attemptResourceUsage.getReserved());
+      Resource neededResource = Resources.add(opportunisticResourceUsedClone,
+          Resources.add(guaranteedResourceUsedClone, reservedResourceClone));
       Resource cluster = rmContext.getScheduler().getClusterResource();
       ResourceCalculator calc =
           rmContext.getScheduler().getResourceCalculator();
@@ -1125,18 +1141,20 @@ public class SchedulerApplicationAttempt implements SchedulableEntity {
         float queueCapacityPerc = queue.getQueueInfo(false, false)
             .getCapacity();
         if (queueCapacityPerc != 0) {
-          queueUsagePerc = calc.divide(cluster, usedResourceClone,
+          queueUsagePerc = calc.divide(cluster, guaranteedResourceUsedClone,
               Resources.multiply(cluster, queueCapacityPerc)) * 100;
         }
         clusterUsagePerc =
-            calc.divide(cluster, usedResourceClone, cluster) * 100;
+            calc.divide(cluster, guaranteedResourceUsedClone, cluster) * 100;
       }
       return ApplicationResourceUsageReport
           .newInstance(liveContainers.size(), reservedContainers.size(),
-              usedResourceClone, reservedResourceClone,
-              Resources.add(usedResourceClone, reservedResourceClone),
-              runningResourceUsage.getResourceUsageSecondsMap(), queueUsagePerc,
-              clusterUsagePerc, preemptedResourceSecondsMaps);
+              guaranteedResourceUsedClone, reservedResourceClone,
+              neededResource,
+              runningResourceUsage.getGuaranteedResourceUsageSecondsMap(),
+              queueUsagePerc, clusterUsagePerc, preemptedResourceSecondsMaps,
+              opportunisticResourceUsedClone,
+              runningResourceUsage.getOpportunisticResourceSecondsMap());
     } finally {
       writeLock.unlock();
     }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/YarnScheduler.java

@@ -172,7 +172,7 @@ public interface YarnScheduler extends EventHandler<SchedulerEvent> {
    */
   @LimitedPrivate("yarn")
   @Evolving
-  ApplicationResourceUsageReport getAppResourceUsageReport(
+  ApplicationResourceUsageReport getAppActiveResourceUsageReport(
       ApplicationAttemptId appAttemptId);
   
   /**

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/common/fica/FiCaSchedulerApp.java

@@ -1111,7 +1111,7 @@ public class FiCaSchedulerApp extends SchedulerApplicationAttempt {
             .getEffectiveCapacity(getAppAMNodePartitionName());
         if (!effCap.equals(Resources.none())) {
           queueUsagePerc = calc.divide(totalPartitionRes,
-              report.getUsedResources(), effCap) * 100;
+              report.getGuaranteedResourcesUsed(), effCap) * 100;
         }
         report.setQueueUsagePercentage(queueUsagePerc);
       }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/fair/FSAppAttempt.java

@@ -169,8 +169,13 @@ public class FSAppAttempt extends SchedulerApplicationAttempt
       queue.getMetrics().releaseResources(
           rmContainer.getNodeLabelExpression(),
           getUser(), 1, containerResource);
-      this.attemptResourceUsage.decUsed(containerResource);
-      getQueue().decUsedGuaranteedResource(containerResource);
+      if (rmContainer.getExecutionType().equals(ExecutionType.GUARANTEED)) {
+        this.attemptResourceUsage.decUsed(containerResource);
+        getQueue().decUsedGuaranteedResource(containerResource);
+      } else {
+        this.attemptOpportunisticResourceUsage.decUsed(containerResource);
+      }
+
 
       // Clear resource utilization metrics cache.
       lastMemoryAggregateAllocationUpdateTime = -1;

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/FairSchedulerAppsBlock.java

@@ -96,6 +96,10 @@ public class FairSchedulerAppsBlock extends HtmlBlock {
             th(".runningcontainer", "Running Containers").
             th(".allocatedCpu", "Allocated CPU VCores").
             th(".allocatedMemory", "Allocated Memory MB").
+            th(".allocatedOpportunisticCpu",
+                "Allocated Opportunistic CPU Vcores").
+            th(".allocatedOpportunisticMemory",
+                "Allocated Opportunistic Memory MB").
             th(".reservedCpu", "Reserved CPU VCores").
             th(".reservedMemory", "Reserved Memory MB").
             th(".progress", "Progress").
@@ -146,6 +150,10 @@ public class FairSchedulerAppsBlock extends HtmlBlock {
         .valueOf(appInfo.getAllocatedVCores())).append("\",\"")
       .append(appInfo.getAllocatedMB() == -1 ? "N/A" : String
         .valueOf(appInfo.getAllocatedMB())).append("\",\"")
+      .append(appInfo.getAllocatedOpportunisticVCores() == -1 ? "N/A" : String
+          .valueOf(appInfo.getAllocatedOpportunisticVCores())).append("\",\"")
+      .append(appInfo.getAllocatedOpportunisticMB() == -1 ? "N/A" : String
+          .valueOf(appInfo.getAllocatedOpportunisticMB())).append("\",\"")
       .append(appInfo.getReservedVCores() == -1 ? "N/A" : String
         .valueOf(appInfo.getReservedVCores())).append("\",\"")
       .append(appInfo.getReservedMB() == -1 ? "N/A" : String

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/RMAppBlock.java

@@ -107,9 +107,12 @@ public class RMAppBlock extends AppBlock{
           attemptResourcePreempted)
         .__("Number of Non-AM Containers Preempted from Current Attempt:",
           attemptNumNonAMContainerPreempted)
-        .__("Aggregate Resource Allocation:", appMetrics == null ? "N/A" :
-            StringHelper
-                .getResourceSecondsString(appMetrics.getResourceSecondsMap()))
+        .__("Aggregate Guaranteed Resource Allocation:", appMetrics == null ?
+            "N/A" : StringHelper.getResourceSecondsString(
+                appMetrics.getGuaranteedResourceSecondsMap()))
+        .__("Aggregate Opportunistic Resource Allocation:", appMetrics == null ?
+            "N/A" : StringHelper.getResourceSecondsString(
+                appMetrics.getOpportunisticResourceSecondsMap()))
         .__("Aggregate Preempted Resource Allocation:",
             appMetrics == null ? "N/A" : StringHelper.getResourceSecondsString(
                 appMetrics.getPreemptedResourceSecondsMap()));

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/RMAppsBlock.java

@@ -70,6 +70,10 @@ public class RMAppsBlock extends AppsBlock {
           .th(".allocatedMemory", "Allocated Memory MB")
           .th(".reservedCpu", "Reserved CPU VCores")
           .th(".reservedMemory", "Reserved Memory MB")
+          .th(".allocatedOpportunisticCpu",
+              "Allocated Opportunistic CPU VCores")
+          .th(".allocatedOpportunisticMemory",
+              "Allocated Opportunistic Memory MB")
           .th(".queuePercentage", "% of Queue")
           .th(".clusterPercentage", "% of Cluster")
           .th(".progress", "Progress")
@@ -157,6 +161,12 @@ public class RMAppsBlock extends AppsBlock {
         .append(app.getReservedMemoryMB() == -1 ? "N/A" :
             String.valueOf(app.getReservedMemoryMB()))
         .append("\",\"")
+        .append(app.getAllocatedOpportunisticCpuVcores() == -1 ? "N/A" : String
+            .valueOf(app.getAllocatedOpportunisticCpuVcores()))
+        .append("\",\"")
+        .append(app.getAllocatedOpportunisticMemoryMB() == -1 ? "N/A" :
+            String.valueOf(app.getAllocatedOpportunisticMemoryMB()))
+        .append("\",\"")
         .append(queuePercent)
         .append("\",\"")
         .append(clusterPercent)

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/dao/AppInfo.java

@@ -97,6 +97,8 @@ public class AppInfo {
   private String masterNodeId;
   private long allocatedMB;
   private long allocatedVCores;
+  private long allocatedOpportunisticMB;
+  private long allocatedOpportunisticVCores;
   private long reservedMB;
   private long reservedVCores;
   private int runningContainers;
@@ -105,6 +107,9 @@ public class AppInfo {
   protected float queueUsagePercentage;
   protected float clusterUsagePercentage;
   protected Map<String, Long> resourceSecondsMap;
+  private long opportunisticMemorySeconds;
+  private long opportunisticVcoreSeconds;
+  private Map<String, Long> opportunisticResourceSecondsMap;
 
   // preemption info fields
   private long preemptedResourceMB;
@@ -205,10 +210,17 @@ public class AppInfo {
           ApplicationResourceUsageReport resourceReport =
               attempt.getApplicationResourceUsageReport();
           if (resourceReport != null) {
-            Resource usedResources = resourceReport.getUsedResources();
+            Resource guaranteedResourcesUsed =
+                resourceReport.getGuaranteedResourcesUsed();
+            Resource opportunisticResourceUsed =
+                resourceReport.getOpportunisticResourcesUsed();
             Resource reservedResources = resourceReport.getReservedResources();
-            allocatedMB = usedResources.getMemorySize();
-            allocatedVCores = usedResources.getVirtualCores();
+            allocatedMB = guaranteedResourcesUsed.getMemorySize();
+            allocatedVCores = guaranteedResourcesUsed.getVirtualCores();
+            allocatedOpportunisticMB =
+                opportunisticResourceUsed.getMemorySize();
+            allocatedOpportunisticVCores =
+                opportunisticResourceUsed.getVirtualCores();
             reservedMB = reservedResources.getMemorySize();
             reservedVCores = reservedResources.getVirtualCores();
             runningContainers = resourceReport.getNumUsedContainers();
@@ -251,9 +263,13 @@ public class AppInfo {
       numNonAMContainerPreempted = appMetrics.getNumNonAMContainersPreempted();
       preemptedResourceVCores =
           appMetrics.getResourcePreempted().getVirtualCores();
-      memorySeconds = appMetrics.getMemorySeconds();
-      vcoreSeconds = appMetrics.getVcoreSeconds();
-      resourceSecondsMap = appMetrics.getResourceSecondsMap();
+      memorySeconds = appMetrics.getGuaranteedMemorySeconds();
+      vcoreSeconds = appMetrics.getGuaranteedVcoreSeconds();
+      resourceSecondsMap = appMetrics.getGuaranteedResourceSecondsMap();
+      opportunisticMemorySeconds = appMetrics.getOpportunisticMemorySeconds();
+      opportunisticVcoreSeconds = appMetrics.getOpportunisticVcoreSeconds();
+      opportunisticResourceSecondsMap =
+          appMetrics.getOpportunisticResourceSecondsMap();
       preemptedMemorySeconds = appMetrics.getPreemptedMemorySeconds();
       preemptedVcoreSeconds = appMetrics.getPreemptedVcoreSeconds();
       preemptedResourceSecondsMap = appMetrics.getPreemptedResourceSecondsMap();
@@ -470,6 +486,13 @@ public class AppInfo {
     return this.allocatedVCores;
   }
 
+  public long getAllocatedOpportunisticMB() {
+    return this.allocatedOpportunisticMB;
+  }
+
+  public long getAllocatedOpportunisticVCores() {
+    return this.allocatedOpportunisticVCores;
+  }
   public long getReservedMB() {
     return this.reservedMB;
   }
@@ -494,18 +517,30 @@ public class AppInfo {
     return numAMContainerPreempted;
   }
 
-  public long getMemorySeconds() {
+  public long getGuaranteedMemorySeconds() {
     return memorySeconds;
   }
 
-  public long getVcoreSeconds() {
+  public long getGuaranteedVcoreSeconds() {
     return vcoreSeconds;
   }
 
-  public Map<String, Long> getResourceSecondsMap() {
+  public long getOpportunisticMemorySeconds() {
+    return opportunisticMemorySeconds;
+  }
+
+  public long getOpportunisticVcoreSeconds() {
+    return opportunisticVcoreSeconds;
+  }
+
+  public Map<String, Long> getGuaranteedResourceSecondsMap() {
     return resourceSecondsMap;
   }
 
+  public Map<String, Long> getOpportunisticResourceSecondsMap() {
+    return opportunisticResourceSecondsMap;
+  }
+
   public long getPreemptedMemorySeconds() {
     return preemptedMemorySeconds;
   }
@@ -598,6 +633,15 @@ public class AppInfo {
     this.allocatedVCores = allocatedVCores;
   }
 
+  public void setAllocatedOpportunisticMB(long allocatedOpportunisticMB) {
+    this.allocatedOpportunisticMB = allocatedOpportunisticMB;
+  }
+
+  public void setAllocatedOpportunisticVCores(
+      long allocatedOpportunisticVCores) {
+    this.allocatedOpportunisticVCores = allocatedOpportunisticVCores;
+  }
+
   public void setReservedMB(long reservedMB) {
     this.reservedMB = reservedMB;
   }
@@ -610,12 +654,20 @@ public class AppInfo {
     this.runningContainers = runningContainers;
   }
 
-  public void setMemorySeconds(long memorySeconds) {
-    this.memorySeconds = memorySeconds;
+  public void setGuaranteedMemorySeconds(long guaranteedMemorySeconds) {
+    this.memorySeconds = guaranteedMemorySeconds;
+  }
+
+  public void setGuaranteedVcoreSeconds(long guaranteedVcoreSeconds) {
+    this.vcoreSeconds = guaranteedVcoreSeconds;
+  }
+
+  public void setOpportunisticMemorySeconds(long oppMemorySeconds) {
+    this.opportunisticMemorySeconds = oppMemorySeconds;
   }
 
-  public void setVcoreSeconds(long vcoreSeconds) {
-    this.vcoreSeconds = vcoreSeconds;
+  public void setOpportunisticVcoreSeconds(long oppVcoreSeconds) {
+    this.opportunisticVcoreSeconds = oppVcoreSeconds;
   }
 
   public void setAppId(String appId) {

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/main/proto/yarn_server_resourcemanager_recovery.proto

@@ -90,6 +90,7 @@ message ApplicationAttemptStateDataProto {
     optional int64 preempted_vcore_seconds = 14;
     repeated StringLongMapProto application_resource_usage_map = 15;
     repeated StringLongMapProto preempted_resource_usage_map = 16;
+    repeated StringLongMapProto application_opportunistic_resource_usage_map = 17;
 }
 
 message EpochProto {

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/TestAppManager.java

@@ -1179,12 +1179,20 @@ public class TestAppManager{
     when(app.getState()).thenReturn(RMAppState.RUNNING);
     when(app.getApplicationType()).thenReturn("MAPREDUCE");
     when(app.getSubmitTime()).thenReturn(1000L);
-    Map<String, Long> resourceSecondsMap = new HashMap<>();
-    resourceSecondsMap.put(ResourceInformation.MEMORY_MB.getName(), 16384L);
-    resourceSecondsMap.put(ResourceInformation.VCORES.getName(), 64L);
+    Map<String, Long> guaranteedResourceSecondsMap = new HashMap<>();
+    guaranteedResourceSecondsMap.put(
+        ResourceInformation.MEMORY_MB.getName(), 16384L);
+    guaranteedResourceSecondsMap.put(
+        ResourceInformation.VCORES.getName(), 64L);
+    Map<String, Long> opportunisticResourceSecondsMap = new HashMap<>();
+    opportunisticResourceSecondsMap.put(
+        ResourceInformation.MEMORY_MB.getName(), 16384L);
+    opportunisticResourceSecondsMap.put(
+        ResourceInformation.VCORES.getName(), 64L);
     RMAppMetrics metrics =
         new RMAppMetrics(Resource.newInstance(1234, 56),
-            10, 1, resourceSecondsMap, new HashMap<>());
+            10, 1, guaranteedResourceSecondsMap,
+            new HashMap<>(), opportunisticResourceSecondsMap);
     when(app.getRMAppMetrics()).thenReturn(metrics);
 
     RMAppManager.ApplicationSummary.SummaryBuilder summary =
@@ -1195,16 +1203,19 @@ public class TestAppManager{
     Assert.assertFalse(msg.contains("\r"));
 
     String escaped = "\\n\\n\\r\\r";
-    assertTrue(msg.contains("Multiline" + escaped +"AppName"));
-    assertTrue(msg.contains("Multiline" + escaped +"UserName"));
-    assertTrue(msg.contains("Multiline" + escaped +"QueueName"));
-    assertTrue(msg.contains("submitTime=1000"));
-    assertTrue(msg.contains("memorySeconds=16384"));
-    assertTrue(msg.contains("vcoreSeconds=64"));
-    assertTrue(msg.contains("preemptedAMContainers=1"));
-    assertTrue(msg.contains("preemptedNonAMContainers=10"));
-    assertTrue(msg.contains("preemptedResources=<memory:1234\\, vCores:56>"));
-    assertTrue(msg.contains("applicationType=MAPREDUCE"));
+    Assert.assertTrue(msg.contains("Multiline" + escaped +"AppName"));
+    Assert.assertTrue(msg.contains("Multiline" + escaped +"UserName"));
+    Assert.assertTrue(msg.contains("Multiline" + escaped +"QueueName"));
+    Assert.assertTrue(msg.contains("submitTime=1000"));
+    Assert.assertTrue(msg.contains("guaranteedMemorySeconds=16384"));
+    Assert.assertTrue(msg.contains("guaranteedVcoreSeconds=64"));
+    Assert.assertTrue(msg.contains("opportunisticMemorySeconds=16384"));
+    Assert.assertTrue(msg.contains("opportunisticVcoreSeconds=64"));
+    Assert.assertTrue(msg.contains("preemptedAMContainers=1"));
+    Assert.assertTrue(msg.contains("preemptedNonAMContainers=10"));
+    Assert.assertTrue(
+        msg.contains("preemptedResources=<memory:1234\\, vCores:56>"));
+    Assert.assertTrue(msg.contains("applicationType=MAPREDUCE"));
  }
 
   @Test

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/TestApplicationACLs.java

@@ -426,9 +426,11 @@ public class TestApplicationACLs extends ParameterizedSchedulerTestBase {
     Assert.assertEquals("Enemy should not see app reserved containers",
         -1, usageReport.getNumReservedContainers());
     Assert.assertEquals("Enemy should not see app used resources",
-        -1, usageReport.getUsedResources().getMemorySize());
+        -1, usageReport.getGuaranteedResourcesUsed().getMemorySize());
     Assert.assertEquals("Enemy should not see app reserved resources",
         -1, usageReport.getReservedResources().getMemorySize());
+    Assert.assertEquals("Enemy should not see app used opportunistic resources",
+        -1, usageReport.getOpportunisticResourcesUsed().getMemorySize());
     Assert.assertEquals("Enemy should not see app needed resources",
         -1, usageReport.getNeededResources().getMemorySize());
   }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/TestClientRMService.java

@@ -385,8 +385,8 @@ public class TestClientRMService {
       ApplicationReport report = response.getApplicationReport();
       ApplicationResourceUsageReport usageReport = 
           report.getApplicationResourceUsageReport();
-      Assert.assertEquals(10, usageReport.getMemorySeconds());
-      Assert.assertEquals(3, usageReport.getVcoreSeconds());
+      Assert.assertEquals(10, usageReport.getGuaranteedMemorySeconds());
+      Assert.assertEquals(3, usageReport.getGuaranteedVcoreSeconds());
       Assert.assertEquals("<Not set>", report.getAmNodeLabelExpression());
       Assert.assertEquals("<Not set>", report.getAppNodeLabelExpression());
 
@@ -1421,26 +1421,28 @@ public class TestClientRMService {
     when(asContext.getMaxAppAttempts()).thenReturn(1);
     when(asContext.getNodeLabelExpression()).thenReturn(appNodeLabelExpression);
     when(asContext.getPriority()).thenReturn(Priority.newInstance(0));
-    RMAppImpl app =
-        spy(new RMAppImpl(applicationId3, rmContext, config, null, null,
+    ResourceRequest resourceRequest = BuilderUtils.newResourceRequest(
+        RMAppAttemptImpl.AM_CONTAINER_PRIORITY, ResourceRequest.ANY,
+        Resource.newInstance(1024, 1), 1);
+    RMAppImpl rmApp =
+        new RMAppImpl(applicationId3, rmContext, config, null, null,
             queueName, asContext, yarnScheduler, null,
             System.currentTimeMillis(), "YARN", null,
-            Collections.singletonList(BuilderUtils.newResourceRequest(
-                RMAppAttemptImpl.AM_CONTAINER_PRIORITY, ResourceRequest.ANY,
-                Resource.newInstance(1024, 1), 1))){
-                  @Override
-                  public ApplicationReport createAndGetApplicationReport(
-                      String clientUserName, boolean allowAccess) {
-                    ApplicationReport report = super.createAndGetApplicationReport(
-                        clientUserName, allowAccess);
-                    ApplicationResourceUsageReport usageReport = 
-                        report.getApplicationResourceUsageReport();
-                    usageReport.setMemorySeconds(memorySeconds);
-                    usageReport.setVcoreSeconds(vcoreSeconds);
-                    report.setApplicationResourceUsageReport(usageReport);
-                    return report;
-                  }
-              });
+            Collections.singletonList(resourceRequest)) {
+          @Override
+          public ApplicationReport createAndGetApplicationReport(
+              String clientUserName, boolean allowAccess) {
+            ApplicationReport report = super.createAndGetApplicationReport(
+                clientUserName, allowAccess);
+            ApplicationResourceUsageReport usageReport =
+                report.getApplicationResourceUsageReport();
+            usageReport.setGuaranteedMemorySeconds(memorySeconds);
+            usageReport.setGuaranteedVcoreSeconds(vcoreSeconds);
+            report.setApplicationResourceUsageReport(usageReport);
+            return report;
+          }
+        };
+    RMAppImpl app = spy(rmApp);
     app.getAMResourceRequests().get(0)
         .setNodeLabelExpression(amNodeLabelExpression);
     ApplicationAttemptId attemptId = ApplicationAttemptId.newInstance(
@@ -1496,7 +1498,8 @@ public class TestClientRMService {
     when(yarnScheduler.getAppsInQueue(QUEUE_2)).thenReturn(
         Arrays.asList(getApplicationAttemptId(103)));
     ApplicationAttemptId attemptId = getApplicationAttemptId(1);
-    when(yarnScheduler.getAppResourceUsageReport(attemptId)).thenReturn(null);
+    when(yarnScheduler.getAppActiveResourceUsageReport(attemptId))
+        .thenReturn(null);
 
     ResourceCalculator rs = mock(ResourceCalculator.class);
     when(yarnScheduler.getResourceCalculator()).thenReturn(rs);

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/TestContainerResourceUsage.java

@@ -23,17 +23,12 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
-import org.apache.commons.lang3.time.DateUtils;
 import org.apache.hadoop.security.UserGroupInformation;
-import org.apache.hadoop.yarn.api.records.ApplicationAccessType;
 import org.apache.hadoop.yarn.api.records.ApplicationAttemptId;
 import org.apache.hadoop.yarn.api.records.Container;
 import org.apache.hadoop.yarn.api.records.ContainerId;
 import org.apache.hadoop.yarn.api.records.ContainerState;
-import org.apache.hadoop.yarn.api.records.Resource;
-import org.apache.hadoop.yarn.api.records.ResourceInformation;
 import org.apache.hadoop.yarn.api.records.ResourceRequest;
 import org.apache.hadoop.yarn.conf.YarnConfiguration;
 import org.apache.hadoop.yarn.server.resourcemanager.recovery.MemoryRMStateStore;
@@ -43,6 +38,7 @@ import org.apache.hadoop.yarn.server.resourcemanager.rmapp.RMAppState;
 import org.apache.hadoop.yarn.server.resourcemanager.rmapp.attempt.RMAppAttempt;
 import org.apache.hadoop.yarn.server.resourcemanager.rmapp.attempt.RMAppAttemptState;
 import org.apache.hadoop.yarn.server.resourcemanager.rmapp.attempt.AggregateAppResourceUsage;
+import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.ContainerResourceUsageReport;
 import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer;
 import org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainerState;
 import org.apache.log4j.Level;
@@ -84,13 +80,13 @@ public class TestContainerResourceUsage {
 
     RMAppMetrics rmAppMetrics = app0.getRMAppMetrics();
     Assert.assertTrue(
-        "Before app submittion, memory seconds should have been 0 but was "
-                          + rmAppMetrics.getMemorySeconds(),
-        rmAppMetrics.getMemorySeconds() == 0);
+        "Before app submission, memory seconds should have been 0 but was "
+                          + rmAppMetrics.getGuaranteedMemorySeconds(),
+        rmAppMetrics.getGuaranteedMemorySeconds() == 0);
     Assert.assertTrue(
         "Before app submission, vcore seconds should have been 0 but was "
-                          + rmAppMetrics.getVcoreSeconds(),
-        rmAppMetrics.getVcoreSeconds() == 0);
+                          + rmAppMetrics.getGuaranteedVcoreSeconds(),
+        rmAppMetrics.getGuaranteedVcoreSeconds() == 0);
 
     RMAppAttempt attempt0 = app0.getCurrentAppAttempt();
 
@@ -105,7 +101,8 @@ public class TestContainerResourceUsage {
     // Allow metrics to accumulate.
     int sleepInterval = 1000;
     int cumulativeSleepTime = 0;
-    while (rmAppMetrics.getMemorySeconds() <= 0 && cumulativeSleepTime < 5000) {
+    while (rmAppMetrics.getGuaranteedMemorySeconds() <= 0
+        && cumulativeSleepTime < 5000) {
       Thread.sleep(sleepInterval);
       cumulativeSleepTime += sleepInterval;
     }
@@ -113,27 +110,35 @@ public class TestContainerResourceUsage {
     rmAppMetrics = app0.getRMAppMetrics();
     Assert.assertTrue(
         "While app is running, memory seconds should be >0 but is "
-            + rmAppMetrics.getMemorySeconds(),
-        rmAppMetrics.getMemorySeconds() > 0);
+            + rmAppMetrics.getGuaranteedMemorySeconds(),
+        rmAppMetrics.getGuaranteedMemorySeconds() > 0);
     Assert.assertTrue(
         "While app is running, vcore seconds should be >0 but is "
-            + rmAppMetrics.getVcoreSeconds(),
-        rmAppMetrics.getVcoreSeconds() > 0);
+            + rmAppMetrics.getGuaranteedVcoreSeconds(),
+        rmAppMetrics.getGuaranteedVcoreSeconds() > 0);
 
     MockRM.finishAMAndVerifyAppState(app0, rm, nm, am0);
 
     AggregateAppResourceUsage ru = calculateContainerResourceMetrics(rmContainer);
     rmAppMetrics = app0.getRMAppMetrics();
 
-    Assert.assertEquals("Unexpected MemorySeconds value",
-        ru.getMemorySeconds(), rmAppMetrics.getMemorySeconds());
-    Assert.assertEquals("Unexpected VcoreSeconds value",
-        ru.getVcoreSeconds(), rmAppMetrics.getVcoreSeconds());
+    Assert.assertEquals("Unexpected GuaranteedMemorySeconds value",
+        ru.getGuaranteedMemorySeconds(),
+        rmAppMetrics.getGuaranteedMemorySeconds());
+    Assert.assertEquals("Unexpected GuaranteedVcoreSeconds value",
+        ru.getGuaranteedVcoreSeconds(),
+        rmAppMetrics.getGuaranteedVcoreSeconds());
+    Assert.assertEquals("Unexpected OpportunisticMemorySeconds value",
+        ru.getOpportunisticMemorySeconds(),
+        rmAppMetrics.getOpportunisticMemorySeconds());
+    Assert.assertEquals("Unexpected OpportunisticVcoreSeconds value",
+        ru.getOpportunisticVcoreSeconds(),
+        rmAppMetrics.getOpportunisticVcoreSeconds());
 
     rm.stop();
   }
 
-  @Test (timeout = 120000)
+  @Test ()
   public void testUsageWithMultipleContainersAndRMRestart() throws Exception {
     // Set max attempts to 1 so that when the first attempt fails, the app
     // won't try to start a new one.
@@ -191,7 +196,7 @@ public class TestContainerResourceUsage {
     // Allow metrics to accumulate.
     int sleepInterval = 1000;
     int cumulativeSleepTime = 0;
-    while (app0.getRMAppMetrics().getMemorySeconds() <= 0
+    while (app0.getRMAppMetrics().getGuaranteedMemorySeconds() <= 0
         && cumulativeSleepTime < 5000) {
       Thread.sleep(sleepInterval);
       cumulativeSleepTime += sleepInterval;
@@ -216,19 +221,29 @@ public class TestContainerResourceUsage {
     rm0.waitForState(nm, cId, RMContainerState.COMPLETED);
 
     // Check that the container metrics match those from the app usage report.
-    long memorySeconds = 0;
-    long vcoreSeconds = 0;
+    long guaranteedMemorySeconds = 0;
+    long guaranteedVcoreSeconds = 0;
+    long opportunisticMemorySeconds = 0;
+    long opportunisticVcoreSeconds = 0;
     for (RMContainer c : rmContainers) {
       AggregateAppResourceUsage ru = calculateContainerResourceMetrics(c);
-      memorySeconds += ru.getMemorySeconds();
-      vcoreSeconds += ru.getVcoreSeconds();
+      guaranteedMemorySeconds += ru.getGuaranteedMemorySeconds();
+      guaranteedVcoreSeconds += ru.getGuaranteedVcoreSeconds();
+      opportunisticMemorySeconds += ru.getOpportunisticMemorySeconds();
+      opportunisticVcoreSeconds += ru.getOpportunisticVcoreSeconds();
     }
 
     RMAppMetrics metricsBefore = app0.getRMAppMetrics();
-    Assert.assertEquals("Unexpected MemorySeconds value",
-        memorySeconds, metricsBefore.getMemorySeconds());
-    Assert.assertEquals("Unexpected VcoreSeconds value",
-        vcoreSeconds, metricsBefore.getVcoreSeconds());
+    Assert.assertEquals("Unexpected GuaranteedMemorySeconds value",
+        guaranteedMemorySeconds, metricsBefore.getGuaranteedMemorySeconds());
+    Assert.assertEquals("Unexpected GuaranteedVcoreSeconds value",
+        guaranteedVcoreSeconds, metricsBefore.getGuaranteedVcoreSeconds());
+    Assert.assertEquals("Unexpected OpportunisticMemorySeconds value",
+        opportunisticMemorySeconds,
+        metricsBefore.getOpportunisticMemorySeconds());
+    Assert.assertEquals("Unexpected OpportunisticVcoreSeconds value",
+        opportunisticVcoreSeconds,
+        metricsBefore.getOpportunisticVcoreSeconds());
 
     // create new RM to represent RM restart. Load up the state store.
     MockRM rm1 = new MockRM(conf, memStore);
@@ -238,10 +253,22 @@ public class TestContainerResourceUsage {
 
     // Compare container resource usage metrics from before and after restart.
     RMAppMetrics metricsAfter = app0After.getRMAppMetrics();
-    Assert.assertEquals("Vcore seconds were not the same after RM Restart",
-        metricsBefore.getVcoreSeconds(), metricsAfter.getVcoreSeconds());
-    Assert.assertEquals("Memory seconds were not the same after RM Restart",
-        metricsBefore.getMemorySeconds(), metricsAfter.getMemorySeconds());
+    Assert.assertEquals(
+        "Guaranteed vcore seconds were not the same after RM Restart",
+        metricsBefore.getGuaranteedVcoreSeconds(),
+        metricsAfter.getGuaranteedVcoreSeconds());
+    Assert.assertEquals(
+        "Guaranteed memory seconds were not the same after RM Restart",
+        metricsBefore.getGuaranteedMemorySeconds(),
+        metricsAfter.getGuaranteedMemorySeconds());
+    Assert.assertEquals(
+        "Opportunistic vcore seconds were not the same after RM Restart",
+        metricsBefore.getOpportunisticVcoreSeconds(),
+        metricsAfter.getOpportunisticVcoreSeconds());
+    Assert.assertEquals(
+        "Opportunistic memory seconds were not the same after RM Restart",
+        metricsBefore.getOpportunisticMemorySeconds(),
+        metricsAfter.getOpportunisticMemorySeconds());
 
     rm0.stop();
     rm0.close();
@@ -264,10 +291,8 @@ public class TestContainerResourceUsage {
     MockRM rm = new MockRM(conf);
     rm.start();
 
-    RMApp app =
-        rm.submitApp(200, "name", "user",
-          new HashMap<ApplicationAccessType, String>(), false, "default", -1,
-          null, "MAPREDUCE", false, keepRunningContainers);
+    RMApp app = rm.submitApp(200, "name", "user", new HashMap<>(), false,
+        "default", -1, null, "MAPREDUCE", false, keepRunningContainers);
     MockNM nm = 
         new MockNM("127.0.0.1:1234", 10240, rm.getResourceTrackerService());
     nm.registerNode();
@@ -275,18 +300,17 @@ public class TestContainerResourceUsage {
     MockAM am0 = MockRM.launchAndRegisterAM(app, rm, nm);
     int NUM_CONTAINERS = 1;
     // allocate NUM_CONTAINERS containers
-    am0.allocate("127.0.0.1", 1024, NUM_CONTAINERS,
-      new ArrayList<ContainerId>());
+    am0.allocate("127.0.0.1", 1024, NUM_CONTAINERS, new ArrayList<>());
     nm.nodeHeartbeat(true);
 
     // wait for containers to be allocated.
     List<Container> containers =
-        am0.allocate(new ArrayList<ResourceRequest>(),
-          new ArrayList<ContainerId>()).getAllocatedContainers();
+        am0.allocate(new ArrayList<>(), new ArrayList<>())
+            .getAllocatedContainers();
     while (containers.size() != NUM_CONTAINERS) {
       nm.nodeHeartbeat(true);
-      containers.addAll(am0.allocate(new ArrayList<ResourceRequest>(),
-        new ArrayList<ContainerId>()).getAllocatedContainers());
+      containers.addAll(am0.allocate(new ArrayList<>(),
+          new ArrayList<>()).getAllocatedContainers());
       Thread.sleep(200);
     }   
 
@@ -294,26 +318,27 @@ public class TestContainerResourceUsage {
     ContainerId containerId2 =
         ContainerId.newContainerId(am0.getApplicationAttemptId(), 2);
     nm.nodeHeartbeat(am0.getApplicationAttemptId(),
-                      containerId2.getContainerId(), ContainerState.RUNNING);
+        containerId2.getContainerId(), ContainerState.RUNNING);
     rm.waitForState(nm, containerId2, RMContainerState.RUNNING);
 
     // Capture the containers here so the metrics can be calculated after the
     // app has completed.
-    Collection<RMContainer> rmContainers =
-        rm.scheduler
-            .getSchedulerAppInfo(am0.getApplicationAttemptId())
-              .getLiveContainers();
+    Collection<RMContainer> rmContainers = rm.scheduler
+        .getSchedulerAppInfo(am0.getApplicationAttemptId())
+            .getLiveContainers();
 
     // fail the first app attempt by sending CONTAINER_FINISHED event without
     // registering.
     ContainerId amContainerId =
         app.getCurrentAppAttempt().getMasterContainer().getId();
     nm.nodeHeartbeat(am0.getApplicationAttemptId(),
-                      amContainerId.getContainerId(), ContainerState.COMPLETE);
+        amContainerId.getContainerId(), ContainerState.COMPLETE);
     rm.waitForState(am0.getApplicationAttemptId(), RMAppAttemptState.FAILED);
     rm.drainEvents();
-    long memorySeconds = 0;
-    long vcoreSeconds = 0;
+    long guaranteedMemorySeconds = 0;
+    long guaranteedVcoreSeconds = 0;
+    long opportunisticMemorySeconds = 0;
+    long opportunisticVcoreSeconds = 0;
 
     // Calculate container usage metrics for first attempt.
     if (keepRunningContainers) {
@@ -321,8 +346,10 @@ public class TestContainerResourceUsage {
       for (RMContainer c : rmContainers) {
         if (c.getContainerId().equals(amContainerId)) {
           AggregateAppResourceUsage ru = calculateContainerResourceMetrics(c);
-          memorySeconds += ru.getMemorySeconds();
-          vcoreSeconds += ru.getVcoreSeconds();
+          guaranteedMemorySeconds += ru.getGuaranteedMemorySeconds();
+          guaranteedVcoreSeconds += ru.getGuaranteedVcoreSeconds();
+          opportunisticVcoreSeconds += ru.getOpportunisticVcoreSeconds();
+          opportunisticMemorySeconds += ru.getOpportunisticMemorySeconds();
         } else {
           // The remaining container should be RUNNING.
           Assert.assertTrue("After first attempt failed, remaining container "
@@ -336,8 +363,10 @@ public class TestContainerResourceUsage {
       for (RMContainer c : rmContainers) {
         waitforContainerCompletion(rm, nm, amContainerId, c);
         AggregateAppResourceUsage ru = calculateContainerResourceMetrics(c);
-        memorySeconds += ru.getMemorySeconds();
-        vcoreSeconds += ru.getVcoreSeconds();
+        guaranteedMemorySeconds += ru.getGuaranteedMemorySeconds();
+        guaranteedVcoreSeconds += ru.getGuaranteedVcoreSeconds();
+        opportunisticMemorySeconds += ru.getOpportunisticMemorySeconds();
+        opportunisticVcoreSeconds += ru.getOpportunisticVcoreSeconds();
       }
     }
 
@@ -355,14 +384,12 @@ public class TestContainerResourceUsage {
     am1.registerAppAttempt();
     rm.waitForState(am1.getApplicationAttemptId(), RMAppAttemptState.RUNNING);
     // allocate NUM_CONTAINERS containers
-    am1.allocate("127.0.0.1", 1024, NUM_CONTAINERS,
-      new ArrayList<ContainerId>());
+    am1.allocate("127.0.0.1", 1024, NUM_CONTAINERS, new ArrayList<>());
     nm.nodeHeartbeat(true);
 
     // wait for containers to be allocated.
-    containers =
-        am1.allocate(new ArrayList<ResourceRequest>(),
-          new ArrayList<ContainerId>()).getAllocatedContainers();
+    containers = am1.allocate(new ArrayList<>(), new ArrayList<>())
+        .getAllocatedContainers();
     while (containers.size() != NUM_CONTAINERS) {
       nm.nodeHeartbeat(true);
       containers.addAll(am1.allocate(new ArrayList<ResourceRequest>(),
@@ -388,19 +415,26 @@ public class TestContainerResourceUsage {
     for (RMContainer c : rmContainers) {
       waitforContainerCompletion(rm, nm, amContainerId, c);
       AggregateAppResourceUsage ru = calculateContainerResourceMetrics(c);
-      memorySeconds += ru.getMemorySeconds();
-      vcoreSeconds += ru.getVcoreSeconds();
+      guaranteedMemorySeconds += ru.getGuaranteedMemorySeconds();
+      guaranteedVcoreSeconds += ru.getGuaranteedVcoreSeconds();
+      opportunisticMemorySeconds += ru.getOpportunisticMemorySeconds();
+      opportunisticVcoreSeconds += ru.getOpportunisticVcoreSeconds();
     }
     
     RMAppMetrics rmAppMetrics = app.getRMAppMetrics();
 
-    Assert.assertEquals("Unexpected MemorySeconds value",
-        memorySeconds, rmAppMetrics.getMemorySeconds());
-    Assert.assertEquals("Unexpected VcoreSeconds value",
-        vcoreSeconds, rmAppMetrics.getVcoreSeconds());
+    Assert.assertEquals("Unexpected GuaranteedMemorySeconds value",
+        guaranteedMemorySeconds, rmAppMetrics.getGuaranteedMemorySeconds());
+    Assert.assertEquals("Unexpected GuaranteedVcoreSeconds value",
+        guaranteedVcoreSeconds, rmAppMetrics.getGuaranteedVcoreSeconds());
+    Assert.assertEquals("Unexpected OpportunisticMemorySeconds value",
+        opportunisticMemorySeconds,
+        rmAppMetrics.getOpportunisticMemorySeconds());
+    Assert.assertEquals("Unexpected OpportunisticVcoreSeconds value",
+        opportunisticVcoreSeconds,
+        rmAppMetrics.getOpportunisticVcoreSeconds());
 
     rm.stop();
-    return;
   }
 
   private void waitforContainerCompletion(MockRM rm, MockNM nm,
@@ -419,16 +453,10 @@ public class TestContainerResourceUsage {
 
   private AggregateAppResourceUsage calculateContainerResourceMetrics(
       RMContainer rmContainer) {
-    Resource resource = rmContainer.getContainer().getResource();
-    long usedMillis =
-        rmContainer.getFinishTime() - rmContainer.getCreationTime();
-    long memorySeconds = resource.getMemorySize()
-                          * usedMillis / DateUtils.MILLIS_PER_SECOND;
-    long vcoreSeconds = resource.getVirtualCores()
-                          * usedMillis / DateUtils.MILLIS_PER_SECOND;
-    Map<String, Long> map = new HashMap<>();
-    map.put(ResourceInformation.MEMORY_MB.getName(), memorySeconds);
-    map.put(ResourceInformation.VCORES.getName(), vcoreSeconds);
-    return new AggregateAppResourceUsage(map);
+    ContainerResourceUsageReport resourceUsageReport =
+        rmContainer.getResourceUsageReport();
+    return new AggregateAppResourceUsage(
+        resourceUsageReport.getGuaranteedResourceUsageSecondsMap(),
+        resourceUsageReport.getOpportunisticResourceSecondsMap());
   }
 }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/applicationsmanager/MockAsm.java

@@ -209,7 +209,7 @@ public abstract class MockAsm extends MockApps {
     @Override
     public RMAppMetrics getRMAppMetrics() {
       return new RMAppMetrics(Resource.newInstance(0, 0), 0, 0, new HashMap<>(),
-          new HashMap<>());
+          new HashMap<>(), new HashMap<>());
     }
 
     @Override
@@ -375,7 +375,7 @@ public abstract class MockAsm extends MockApps {
         ApplicationResourceUsageReport usageReport =
             ApplicationResourceUsageReport
                 .newInstance(0, 0, null, null, null, new HashMap<>(), 0, 0,
-                    new HashMap<>());
+                    new HashMap<>(), null, new HashMap<>());
         ApplicationReport report = ApplicationReport.newInstance(
             getApplicationId(), appAttemptId, getUser(), getQueue(), 
             getName(), null, 0, null, null, getDiagnostics().toString(), 

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/metrics/TestCombinedSystemMetricsPublisher.java

@@ -479,7 +479,7 @@ public class TestCombinedSystemMetricsPublisher {
     preemptedMap.put(ResourceInformation.VCORES.getName(), Long.MAX_VALUE);
     when(rmApp.getRMAppMetrics()).thenReturn(
         new RMAppMetrics(Resource.newInstance(0, 0), 0, 0, resourceMap,
-            preemptedMap));
+            preemptedMap, new HashMap<>()));
     when(rmApp.getApplicationTags()).thenReturn(
         Collections.<String> emptySet());
     ApplicationSubmissionContext appSubmissionContext =

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/metrics/TestSystemMetricsPublisher.java

@@ -219,13 +219,25 @@ public class TestSystemMetricsPublisher {
             entity.getOtherInfo().get(
                 ApplicationMetricsConstants.APP_VIEW_ACLS_ENTITY_INFO));
         Assert.assertEquals(
-            app.getRMAppMetrics().getMemorySeconds(),
+            app.getRMAppMetrics().getGuaranteedMemorySeconds(),
             Long.parseLong(entity.getOtherInfo()
-                .get(ApplicationMetricsConstants.APP_MEM_METRICS).toString()));
+                .get(ApplicationMetricsConstants.APP_GUARANTEED_MEM_METRICS)
+                .toString()));
+        Assert.assertEquals(
+            app.getRMAppMetrics().getGuaranteedVcoreSeconds(),
+            Long.parseLong(entity.getOtherInfo()
+                .get(ApplicationMetricsConstants.APP_GUARANTEED_CPU_METRICS)
+                .toString()));
         Assert.assertEquals(
-            app.getRMAppMetrics().getVcoreSeconds(),
+            app.getRMAppMetrics().getOpportunisticMemorySeconds(),
             Long.parseLong(entity.getOtherInfo()
-                .get(ApplicationMetricsConstants.APP_CPU_METRICS).toString()));
+                .get(ApplicationMetricsConstants.APP_OPPORTUNISTIC_MEM_METRICS)
+                .toString()));
+        Assert.assertEquals(
+            app.getRMAppMetrics().getOpportunisticVcoreSeconds(),
+            Long.parseLong(entity.getOtherInfo()
+                .get(ApplicationMetricsConstants.APP_OPPORTUNISTIC_CPU_METRICS)
+                .toString()));
         Assert.assertEquals(
             app.getRMAppMetrics().getPreemptedMemorySeconds(),
             Long.parseLong(entity.getOtherInfo()
@@ -517,7 +529,8 @@ public class TestSystemMetricsPublisher {
         .put(ResourceInformation.MEMORY_MB.getName(), (long) Integer.MAX_VALUE);
     preemptedMap.put(ResourceInformation.VCORES.getName(), Long.MAX_VALUE);
     when(app.getRMAppMetrics())
-        .thenReturn(new RMAppMetrics(null, 0, 0, resourceMap, preemptedMap));
+        .thenReturn(new RMAppMetrics(null, 0, 0,
+            resourceMap, preemptedMap, new HashMap<>()));
     Set<String> appTags = new HashSet<String>();
     appTags.add("test");
     appTags.add("tags");

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/metrics/TestSystemMetricsPublisherForV2.java

@@ -221,7 +221,7 @@ public class TestSystemMetricsPublisherForV2 {
     File appFile = new File(outputDirApp, timelineServiceFileName);
     Assert.assertTrue(appFile.exists());
     verifyEntity(
-        appFile, 3, ApplicationMetricsConstants.CREATED_EVENT_TYPE, 8, 0);
+        appFile, 3, ApplicationMetricsConstants.CREATED_EVENT_TYPE, 10, 0);
   }
 
   @Test(timeout = 10000)
@@ -365,14 +365,14 @@ public class TestSystemMetricsPublisherForV2 {
     when(app.getCurrentAppAttempt()).thenReturn(appAttempt);
     when(app.getFinalApplicationStatus())
         .thenReturn(FinalApplicationStatus.UNDEFINED);
-    Map<String, Long> resourceSecondsMap = new HashMap<>();
-    resourceSecondsMap
+    Map<String, Long> guaranteedResourceSecondsMap = new HashMap<>();
+    guaranteedResourceSecondsMap
         .put(ResourceInformation.MEMORY_MB.getName(), (long) Integer.MAX_VALUE);
-    resourceSecondsMap
+    guaranteedResourceSecondsMap
         .put(ResourceInformation.VCORES.getName(), Long.MAX_VALUE);
     when(app.getRMAppMetrics()).thenReturn(
-        new RMAppMetrics(Resource.newInstance(0, 0), 0, 0, resourceSecondsMap,
-            new HashMap<>()));
+        new RMAppMetrics(Resource.newInstance(0, 0), 0, 0,
+            guaranteedResourceSecondsMap, new HashMap<>(), new HashMap<>()));
     when(app.getApplicationTags()).thenReturn(Collections.<String>emptySet());
     ApplicationSubmissionContext appSubmissionContext =
         mock(ApplicationSubmissionContext.class);

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/recovery/RMStateStoreTestBase.java

@@ -202,7 +202,8 @@ public class RMStateStoreTestBase {
     when(mockAttempt.getRMAppAttemptMetrics())
         .thenReturn(mockRmAppAttemptMetrics);
     when(mockRmAppAttemptMetrics.getAggregateAppResourceUsage())
-        .thenReturn(new AggregateAppResourceUsage(new HashMap<>()));
+        .thenReturn(new AggregateAppResourceUsage(
+            new HashMap<>(), new HashMap<>()));
     dispatcher.attemptId = attemptId;
     store.storeNewApplicationAttempt(mockAttempt);
     waitNotify(dispatcher);
@@ -300,7 +301,8 @@ public class RMStateStoreTestBase {
     when(mockRemovedAttempt.getRMAppAttemptMetrics())
         .thenReturn(mockRmAppAttemptMetrics);
     when(mockRmAppAttemptMetrics.getAggregateAppResourceUsage())
-        .thenReturn(new AggregateAppResourceUsage(new HashMap<>()));
+        .thenReturn(new AggregateAppResourceUsage(
+            new HashMap<>(), new HashMap<>()));
     attempts.put(attemptIdRemoved, mockRemovedAttempt);
     store.removeApplication(mockRemovedApp);
 
@@ -377,7 +379,8 @@ public class RMStateStoreTestBase {
             oldAttemptState.getStartTime(), RMAppAttemptState.FINISHED,
             "myTrackingUrl", "attemptDiagnostics",
             FinalApplicationStatus.SUCCEEDED, 100,
-            oldAttemptState.getFinishTime(), new HashMap<>(), new HashMap<>());
+            oldAttemptState.getFinishTime(), new HashMap<>(),
+            new HashMap<>(), new HashMap<>());
     store.updateApplicationAttemptState(newAttemptState);
 
     // test updating the state of an app/attempt whose initial state was not
@@ -402,7 +405,8 @@ public class RMStateStoreTestBase {
             oldAttemptState.getStartTime(), RMAppAttemptState.FINISHED,
             "myTrackingUrl", "attemptDiagnostics",
             FinalApplicationStatus.SUCCEEDED, 111,
-            oldAttemptState.getFinishTime(), new HashMap<>(), new HashMap<>());
+            oldAttemptState.getFinishTime(), new HashMap<>(),
+            new HashMap<>(), new HashMap<>());
     store.updateApplicationAttemptState(dummyAttempt);
 
     // let things settle down

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/recovery/TestZKRMStateStore.java

@@ -555,7 +555,8 @@ public class TestZKRMStateStore extends RMStateStoreTestBase {
     when(mockAttempt.getRMAppAttemptMetrics())
         .thenReturn(mockRmAppAttemptMetrics);
     when(mockRmAppAttemptMetrics.getAggregateAppResourceUsage())
-        .thenReturn(new AggregateAppResourceUsage(new HashMap<>()));
+        .thenReturn(new AggregateAppResourceUsage(new HashMap<>(),
+            new HashMap<>(0)));
     store.storeNewApplicationAttempt(mockAttempt);
     assertEquals("RMStateStore should have been in fenced state",
             true, store.isFencedState());
@@ -567,7 +568,7 @@ public class TestZKRMStateStore extends RMStateStoreTestBase {
             store.getCredentialsFromAppAttempt(mockAttempt),
             startTime, RMAppAttemptState.FINISHED, "testUrl", 
             "test", FinalApplicationStatus.SUCCEEDED, 100, 
-            finishTime, new HashMap<>(), new HashMap<>());
+            finishTime, new HashMap<>(), new HashMap<>(), new HashMap<>());
     store.updateApplicationAttemptState(newAttemptState);
     assertEquals("RMStateStore should have been in fenced state",
             true, store.isFencedState());
@@ -804,20 +805,33 @@ public class TestZKRMStateStore extends RMStateStoreTestBase {
   private static ApplicationAttemptStateData createFinishedAttempt(
       ApplicationAttemptId attemptId, Container container, long startTime,
       int amExitStatus) {
-    Map<String, Long> resourceSecondsMap = new HashMap<>();
-    Map<String, Long> preemptedResoureSecondsMap = new HashMap<>();
-    resourceSecondsMap
-        .put(ResourceInformation.MEMORY_MB.getName(), 0L);
-    resourceSecondsMap
-        .put(ResourceInformation.VCORES.getName(), 0L);
-    preemptedResoureSecondsMap.put(ResourceInformation.MEMORY_MB.getName(),
-        0L);
-    preemptedResoureSecondsMap
-        .put(ResourceInformation.VCORES.getName(), 0L);
+    Map<String, Long> guaranteedResourceSecondsMap =
+        new HashMap<String, Long>() {
+          {
+            put(ResourceInformation.MEMORY_MB.getName(), 0L);
+            put(ResourceInformation.VCORES.getName(), 0L);
+          }
+    };
+    Map<String, Long> opportunisticResourceSecondsMap =
+        new HashMap<String, Long>() {
+          {
+            put(ResourceInformation.MEMORY_MB.getName(), 0L);
+            put(ResourceInformation.VCORES.getName(), 0L);
+          }
+    };
+    Map<String, Long> preemptedResoureSecondsMap =
+        new HashMap<String, Long>() {
+          {
+            put(ResourceInformation.MEMORY_MB.getName(), 0L);
+            put(ResourceInformation.VCORES.getName(), 0L);
+          }
+    };
+
     return ApplicationAttemptStateData.newInstance(attemptId,
         container, null, startTime, RMAppAttemptState.FINISHED,
         "myTrackingUrl", "attemptDiagnostics", FinalApplicationStatus.SUCCEEDED,
-        amExitStatus, 0, resourceSecondsMap, preemptedResoureSecondsMap);
+        amExitStatus, 0, guaranteedResourceSecondsMap,
+        preemptedResoureSecondsMap, opportunisticResourceSecondsMap);
   }
 
   private ApplicationAttemptId storeAttempt(RMStateStore store,

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/rmapp/TestRMAppTransitions.java

@@ -54,7 +54,6 @@ import org.apache.hadoop.security.UserGroupInformation;
 import org.apache.hadoop.security.UserGroupInformation.AuthenticationMethod;
 import org.apache.hadoop.yarn.MockApps;
 import org.apache.hadoop.yarn.api.ApplicationConstants.Environment;
-import org.apache.hadoop.yarn.api.records.ApplicationAttemptId;
 import org.apache.hadoop.yarn.api.records.ApplicationId;
 import org.apache.hadoop.yarn.api.records.ApplicationReport;
 import org.apache.hadoop.yarn.api.records.ApplicationSubmissionContext;
@@ -243,7 +242,7 @@ public class TestRMAppTransitions {
 
     ResourceScheduler resourceScheduler = mock(ResourceScheduler.class);
     doReturn(null).when(resourceScheduler)
-              .getAppResourceUsageReport((ApplicationAttemptId)Matchers.any());
+        .getAppActiveResourceUsageReport(Matchers.any());
     doReturn(resourceScheduler).when(rmContext).getScheduler();
 
     doReturn(mock(RMTimelineCollectorManager.class)).when(rmContext)
@@ -1249,7 +1248,8 @@ public class TestRMAppTransitions {
     assertAppState(RMAppState.NEW, app);
     ApplicationReport report = app.createAndGetApplicationReport(null, true);
     Assert.assertNotNull(report.getApplicationResourceUsageReport());
-    Assert.assertEquals(report.getApplicationResourceUsageReport(),RMServerUtils.DUMMY_APPLICATION_RESOURCE_USAGE_REPORT);
+    Assert.assertEquals(RMServerUtils.DUMMY_APPLICATION_RESOURCE_USAGE_REPORT,
+        report.getApplicationResourceUsageReport());
     report = app.createAndGetApplicationReport("clientuser", true);
     Assert.assertNotNull(report.getApplicationResourceUsageReport());
     Assert.assertTrue("bad proxy url for app",

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/rmapp/attempt/TestRMAppAttemptTransitions.java

@@ -299,10 +299,12 @@ public class TestRMAppAttemptTransitions {
 
     ApplicationResourceUsageReport appResUsgRpt =
         mock(ApplicationResourceUsageReport.class);
-    when(appResUsgRpt.getMemorySeconds()).thenReturn(0L);
-    when(appResUsgRpt.getVcoreSeconds()).thenReturn(0L);
+    when(appResUsgRpt.getGuaranteedMemorySeconds()).thenReturn(0L);
+    when(appResUsgRpt.getGuaranteedVcoreSeconds()).thenReturn(0L);
+    when(appResUsgRpt.getOpportunisticMemorySeconds()).thenReturn(0L);
+    when(appResUsgRpt.getOpportunisticVcoreSeconds()).thenReturn(0L);
     when(resourceScheduler
-        .getAppResourceUsageReport((ApplicationAttemptId)Matchers.any()))
+        .getAppActiveResourceUsageReport((ApplicationAttemptId)Matchers.any()))
      .thenReturn(appResUsgRpt);
     spyRMContext = spy(rmContext);
     Mockito.doReturn(resourceScheduler).when(spyRMContext).getScheduler();
@@ -762,10 +764,12 @@ public class TestRMAppAttemptTransitions {
     ApplicationAttemptId attemptId = applicationAttempt.getAppAttemptId();
     ApplicationResourceUsageReport appResUsgRpt =
             mock(ApplicationResourceUsageReport.class);
-    when(appResUsgRpt.getMemorySeconds()).thenReturn(123456L);
-    when(appResUsgRpt.getVcoreSeconds()).thenReturn(55544L);
-    when(scheduler.getAppResourceUsageReport(any(ApplicationAttemptId.class)))
-    .thenReturn(appResUsgRpt);
+    when(appResUsgRpt.getGuaranteedMemorySeconds()).thenReturn(123456L);
+    when(appResUsgRpt.getGuaranteedVcoreSeconds()).thenReturn(55544L);
+    when(appResUsgRpt.getOpportunisticMemorySeconds()).thenReturn(123456L);
+    when(appResUsgRpt.getOpportunisticVcoreSeconds()).thenReturn(55544L);
+    when(scheduler.getAppActiveResourceUsageReport(
+        any(ApplicationAttemptId.class))).thenReturn(appResUsgRpt);
 
     // start and finish the attempt
     Container amContainer = allocateApplicationAttempt();
@@ -777,12 +781,14 @@ public class TestRMAppAttemptTransitions {
     // expect usage stats to come from the scheduler report
     ApplicationResourceUsageReport report = 
         applicationAttempt.getApplicationResourceUsageReport();
-    Assert.assertEquals(123456L, report.getMemorySeconds());
-    Assert.assertEquals(55544L, report.getVcoreSeconds());
+    Assert.assertEquals(123456L, report.getGuaranteedMemorySeconds());
+    Assert.assertEquals(55544L, report.getGuaranteedVcoreSeconds());
+    Assert.assertEquals(123456L, report.getOpportunisticMemorySeconds());
+    Assert.assertEquals(55544L, report.getOpportunisticVcoreSeconds());
 
     // finish app attempt and remove it from scheduler 
-    when(appResUsgRpt.getMemorySeconds()).thenReturn(223456L);
-    when(appResUsgRpt.getVcoreSeconds()).thenReturn(75544L);
+    when(appResUsgRpt.getGuaranteedMemorySeconds()).thenReturn(223456L);
+    when(appResUsgRpt.getGuaranteedVcoreSeconds()).thenReturn(75544L);
     sendAttemptUpdateSavedEvent(applicationAttempt);
     NodeId anyNodeId = NodeId.newInstance("host", 1234);
     applicationAttempt.handle(new RMAppAttemptContainerFinishedEvent(
@@ -793,8 +799,8 @@ public class TestRMAppAttemptTransitions {
     when(scheduler.getSchedulerAppInfo(eq(attemptId))).thenReturn(null);
 
     report = applicationAttempt.getApplicationResourceUsageReport();
-    Assert.assertEquals(223456, report.getMemorySeconds());
-    Assert.assertEquals(75544, report.getVcoreSeconds());
+    Assert.assertEquals(223456, report.getGuaranteedMemorySeconds());
+    Assert.assertEquals(75544, report.getGuaranteedVcoreSeconds());
   }
 
   @Test

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestCapacityScheduler.java

@@ -2838,7 +2838,7 @@ public class TestCapacityScheduler extends CapacitySchedulerTestBase {
     Thread.sleep(1000);
     AllocateResponse allocResponse = am1.schedule();
     ApplicationResourceUsageReport report =
-        rm.getResourceScheduler().getAppResourceUsageReport(
+        rm.getResourceScheduler().getAppActiveResourceUsageReport(
           attempt1.getAppAttemptId());
     Assert.assertEquals(0, allocResponse.getAllocatedContainers().size());
     Assert.assertEquals(0, report.getNumReservedContainers());
@@ -2851,7 +2851,7 @@ public class TestCapacityScheduler extends CapacitySchedulerTestBase {
       allocResponse = am1.schedule();
     }
     report =
-        rm.getResourceScheduler().getAppResourceUsageReport(
+        rm.getResourceScheduler().getAppActiveResourceUsageReport(
           attempt1.getAppAttemptId());
     Assert.assertEquals(1, allocResponse.getAllocatedContainers().size());
     Assert.assertEquals(0, report.getNumReservedContainers());

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/scheduler/capacity/TestCapacitySchedulerNodeLabelUpdate.java

@@ -223,23 +223,23 @@ public class TestCapacitySchedulerNodeLabelUpdate {
     RMApp app1 = rm.submitApp(GB, "app", "user", null, "a");
     MockAM am1 = MockRM.launchAndRegisterAM(app1, rm, nm3);
     ApplicationResourceUsageReport appResourceUsageReport =
-        rm.getResourceScheduler().getAppResourceUsageReport(
+        rm.getResourceScheduler().getAppActiveResourceUsageReport(
             am1.getApplicationAttemptId());
-    Assert.assertEquals(1024, appResourceUsageReport.getUsedResources()
-        .getMemorySize());
-    Assert.assertEquals(1, appResourceUsageReport.getUsedResources()
-        .getVirtualCores());
+    Assert.assertEquals(1024, appResourceUsageReport
+        .getGuaranteedResourcesUsed().getMemorySize());
+    Assert.assertEquals(1, appResourceUsageReport
+        .getGuaranteedResourcesUsed().getVirtualCores());
     // request a container.
     am1.allocate("*", GB, 1, new ArrayList<ContainerId>(), "x");
     containerId = ContainerId.newContainerId(am1.getApplicationAttemptId(), 2);
     rm.waitForState(nm1, containerId, RMContainerState.ALLOCATED);
     appResourceUsageReport =
-        rm.getResourceScheduler().getAppResourceUsageReport(
+        rm.getResourceScheduler().getAppActiveResourceUsageReport(
             am1.getApplicationAttemptId());
-    Assert.assertEquals(2048, appResourceUsageReport.getUsedResources()
-        .getMemorySize());
-    Assert.assertEquals(2, appResourceUsageReport.getUsedResources()
-        .getVirtualCores());
+    Assert.assertEquals(2048, appResourceUsageReport
+        .getGuaranteedResourcesUsed().getMemorySize());
+    Assert.assertEquals(2, appResourceUsageReport
+        .getGuaranteedResourcesUsed().getVirtualCores());
     LeafQueue queue =
         (LeafQueue) ((CapacityScheduler) rm.getResourceScheduler())
             .getQueue("a");

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/TestAppPage.java

@@ -66,7 +66,7 @@ public class TestAppPage {
 
     RMAppMetrics appMetrics =
         new RMAppMetrics(Resource.newInstance(0, 0), 0, 0, new HashMap<>(),
-            new HashMap<>());
+            new HashMap<>(), new HashMap<>());
     when(app.getRMAppMetrics()).thenReturn(appMetrics);
     
     // initialize RM Context, and create RMApp, without creating RMAppAttempt

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/TestRMWebApp.java

@@ -37,7 +37,6 @@ import org.apache.hadoop.yarn.api.protocolrecords.GetApplicationsResponse;
 import org.apache.hadoop.yarn.api.records.ApplicationAttemptId;
 import org.apache.hadoop.yarn.api.records.ApplicationId;
 import org.apache.hadoop.yarn.api.records.ApplicationReport;
-import org.apache.hadoop.yarn.api.records.ApplicationResourceUsageReport;
 import org.apache.hadoop.yarn.api.records.NodeId;
 import org.apache.hadoop.yarn.api.records.NodeState;
 import org.apache.hadoop.yarn.api.records.Token;
@@ -259,7 +258,7 @@ public class TestRMWebApp {
               app.getDiagnostics().toString(), (String) null,
               app.getStartTime(), app.getLaunchTime(), app.getFinishTime(),
               app.getFinalApplicationStatus(),
-              (ApplicationResourceUsageReport) null, app.getTrackingUrl(),
+              null, app.getTrackingUrl(),
               app.getProgress(), app.getApplicationType(), (Token) null);
       appReports.add(appReport);
     }

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/TestRMWebAppFairScheduler.java

@@ -138,7 +138,7 @@ public class TestRMWebAppFairScheduler {
         @Override
         public RMAppMetrics getRMAppMetrics() {
           return new RMAppMetrics(Resource.newInstance(0, 0), 0, 0,
-              new HashMap<>(), new HashMap<>());
+              new HashMap<>(), new HashMap<>(), new HashMap<>());
         }
         @Override
         public YarnApplicationState createApplicationState() {

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/TestRMWebServicesApps.java

@@ -1605,7 +1605,7 @@ public class TestRMWebServicesApps extends JerseyTestBase {
   public void verifyAppInfo(JSONObject info, RMApp app, boolean hasResourceReqs)
       throws JSONException, Exception {
 
-    int expectedNumberOfElements = 40 + (hasResourceReqs ? 2 : 0);
+    int expectedNumberOfElements = 45 + (hasResourceReqs ? 2 : 0);
     String appNodeLabelExpression = null;
     String amNodeLabelExpression = null;
     if (app.getApplicationSubmissionContext()

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-resourcemanager/src/test/java/org/apache/hadoop/yarn/server/resourcemanager/webapp/TestRMWebServicesAppsCustomResourceTypes.java

@@ -222,7 +222,7 @@ public class TestRMWebServicesAppsCustomResourceTypes extends JerseyTestBase {
   }
 
   private int getExpectedNumberOfElements(RMApp app) {
-    int expectedNumberOfElements = 40 + 2; // 2 -> resourceRequests
+    int expectedNumberOfElements = 45 + 2; // 2 -> resourceRequests
     if (app.getApplicationSubmissionContext()
         .getNodeLabelExpression() != null) {
       expectedNumberOfElements++;

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-router/src/main/java/org/apache/hadoop/yarn/server/router/webapp/RouterWebServiceUtil.java

@@ -339,12 +339,22 @@ public final class RouterWebServiceUtil {
 
       am.setAllocatedMB(am.getAllocatedMB() + uam.getAllocatedMB());
       am.setAllocatedVCores(am.getAllocatedVCores() + uam.getAllocatedVCores());
+      am.setAllocatedOpportunisticMB(am.getAllocatedOpportunisticMB() +
+          uam.getAllocatedOpportunisticMB());
+      am.setAllocatedOpportunisticVCores(am.getAllocatedOpportunisticVCores() +
+          uam.getAllocatedOpportunisticVCores());
       am.setReservedMB(am.getReservedMB() + uam.getReservedMB());
       am.setReservedVCores(am.getReservedVCores() + uam.getReservedMB());
       am.setRunningContainers(
           am.getRunningContainers() + uam.getRunningContainers());
-      am.setMemorySeconds(am.getMemorySeconds() + uam.getMemorySeconds());
-      am.setVcoreSeconds(am.getVcoreSeconds() + uam.getVcoreSeconds());
+      am.setGuaranteedMemorySeconds(am.getGuaranteedMemorySeconds() +
+          uam.getGuaranteedMemorySeconds());
+      am.setGuaranteedVcoreSeconds(am.getGuaranteedVcoreSeconds() +
+          uam.getGuaranteedVcoreSeconds());
+      am.setOpportunisticVcoreSeconds(am.getOpportunisticVcoreSeconds() +
+          uam.getOpportunisticVcoreSeconds());
+      am.setOpportunisticMemorySeconds(am.getOpportunisticMemorySeconds() +
+          uam.getOpportunisticMemorySeconds());
     }
   }
 

hadoop-yarn-project/hadoop-yarn/hadoop-yarn-server/hadoop-yarn-server-router/src/test/java/org/apache/hadoop/yarn/server/router/webapp/TestRouterWebServiceUtil.java

@@ -249,8 +249,10 @@ public class TestRouterWebServiceUtil {
     Assert.assertEquals(value * 3, app.getReservedMB());
     Assert.assertEquals(value * 3, app.getReservedVCores());
     Assert.assertEquals(value * 3, app.getRunningContainers());
-    Assert.assertEquals(value * 3, app.getMemorySeconds());
-    Assert.assertEquals(value * 3, app.getVcoreSeconds());
+    Assert.assertEquals(value * 3, app.getGuaranteedMemorySeconds());
+    Assert.assertEquals(value * 3, app.getGuaranteedVcoreSeconds());
+    Assert.assertEquals(value * 3, app.getOpportunisticMemorySeconds());
+    Assert.assertEquals(value * 3, app.getOpportunisticVcoreSeconds());
     Assert.assertEquals(3, app.getResourceRequests().size());
   }
 
@@ -258,11 +260,15 @@ public class TestRouterWebServiceUtil {
     am.getResourceRequests().add(new ResourceRequestInfo());
     am.setAllocatedMB(value);
     am.setAllocatedVCores(value);
+    am.setAllocatedOpportunisticVCores(value);
+    am.setAllocatedOpportunisticMB(value);
     am.setReservedMB(value);
     am.setReservedVCores(value);
     am.setRunningContainers(value);
-    am.setMemorySeconds(value);
-    am.setVcoreSeconds(value);
+    am.setGuaranteedMemorySeconds(value);
+    am.setGuaranteedVcoreSeconds(value);
+    am.setOpportunisticMemorySeconds(value);
+    am.setOpportunisticVcoreSeconds(value);
   }
 
   /**