[mesos] 01/04: Simplified quota chopping logic in the allocator.

[mz...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

mzhu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mesos.git

commit fbfe1938846ef02a90dcae500a2c7843f902d1bf
Author: Meng Zhu <mz...@mesosphere.io>
AuthorDate: Fri Mar 29 15:02:02 2019 -0700

    Simplified quota chopping logic in the allocator.
    
    This patch refactors the `shrinkResources()` helper
    to take in a target `ResourceQuantities`.
    Due to the absent-means-zero semantic of
    `class ResourceQuantities`, we also change the function
    to drop (shrink to zero) resources that are absent in
    the input `ResourceQuantities`.
    
    Review: https://reviews.apache.org/r/70345
---
 src/master/allocator/mesos/hierarchical.cpp | 70 +++++++++--------------------
 1 file changed, 21 insertions(+), 49 deletions(-)

diff --git a/src/master/allocator/mesos/hierarchical.cpp b/src/master/allocator/mesos/hierarchical.cpp
index ef4f968..f2393ed 100644
--- a/src/master/allocator/mesos/hierarchical.cpp
+++ b/src/master/allocator/mesos/hierarchical.cpp
@@ -1633,8 +1633,7 @@ void HierarchicalAllocatorProcess::__allocate()
   std::random_shuffle(slaveIds.begin(), slaveIds.end());
 
   // Returns the result of shrinking the provided resources down to the
-  // target scalar quantities. If a resource does not have a target
-  // quantity provided, it will not be shrunk.
+  // target resource quantities.
   //
   // Note that some resources are indivisible (e.g. MOUNT volume) and
   // may be excluded in entirety in order to achieve the target size
@@ -1643,27 +1642,27 @@ void HierarchicalAllocatorProcess::__allocate()
   // Note also that there may be more than one result that satisfies
   // the target sizes (e.g. need to exclude 1 of 2 disks); this function
   // will make a random choice in these cases.
-  auto shrinkResources =
-    [](const Resources& resources,
-       hashmap<string, Value::Scalar> targetScalarQuantites) {
-    google::protobuf::RepeatedPtrField<Resource>
-      resourceVector = resources;
+  auto shrinkResources = [](const Resources& resources,
+                            ResourceQuantities target) {
+    if (target.empty()) {
+      return Resources();
+    }
+
+    google::protobuf::RepeatedPtrField<Resource> resourceVector = resources;
 
     random_shuffle(resourceVector.begin(), resourceVector.end());
 
     Resources result;
     foreach (Resource& resource, resourceVector) {
-      if (!targetScalarQuantites.contains(resource.name())) {
-        // Resource that has no target quantity is left as is.
-        result += std::move(resource);
+      Value::Scalar scalar = target.get(resource.name());
+
+      if (scalar == Value::Scalar()) {
+        // Resource that has zero quantity is dropped (shrunk to zero).
         continue;
       }
 
-      Option<Value::Scalar> limitScalar =
-        targetScalarQuantites.get(resource.name());
-
-      if (Resources::shrink(&resource, limitScalar.get())) {
-        targetScalarQuantites[resource.name()] -= resource.scalar();
+      if (Resources::shrink(&resource, scalar)) {
+        target -= ResourceQuantities::fromScalarResources(resource);
         result += std::move(resource);
       }
     }
@@ -1910,21 +1909,9 @@ void HierarchicalAllocatorProcess::__allocate()
         Resources unreserved = available.nonRevocable().unreserved();
 
         // First, allocate resources up to a role's quota guarantee.
-
-        hashmap<string, Value::Scalar> unsatisfiedQuotaGuaranteeScalarLimit;
-        foreach (const string& name, unsatisfiedQuotaGuarantee.names()) {
-          unsatisfiedQuotaGuaranteeScalarLimit[name] +=
-            CHECK_NOTNONE(unsatisfiedQuotaGuarantee.get<Value::Scalar>(name));
-        }
-
-        Resources newQuotaAllocation =
-          unreserved.filter([&](const Resource& resource) {
-            return
-              unsatisfiedQuotaGuaranteeScalarLimit.contains(resource.name());
-          });
-
-        newQuotaAllocation = shrinkResources(newQuotaAllocation,
-            unsatisfiedQuotaGuaranteeScalarLimit);
+        Resources newQuotaAllocation = shrinkResources(
+            unreserved,
+            ResourceQuantities::fromScalarResources(unsatisfiedQuotaGuarantee));
 
         toAllocate += newQuotaAllocation;
 
@@ -1950,26 +1937,11 @@ void HierarchicalAllocatorProcess::__allocate()
               }
           );
 
-        // Allocation Limit = Available Headroom - Required Headroom
-        Resources headroomResourcesLimit = availableHeadroom - requiredHeadroom;
-
-        hashmap<string, Value::Scalar> headroomScalarLimit;
-        foreach (const string& name, headroomResourcesLimit.names()) {
-          headroomScalarLimit[name] =
-            CHECK_NOTNONE(headroomResourcesLimit.get<Value::Scalar>(name));
-        }
-
-        // If a resource type is absent in `headroomScalarLimit`, it means this
-        // type of resource is already in quota headroom deficit and we make
-        // no more allocations. They are filtered out.
-        nonQuotaGuaranteeResources = nonQuotaGuaranteeResources.filter(
-            [&] (const Resource& resource) {
-              return headroomScalarLimit.contains(resource.name());
-            }
-          );
+        Resources surplusHeadroom = availableHeadroom - requiredHeadroom;
 
-        nonQuotaGuaranteeResources =
-          shrinkResources(nonQuotaGuaranteeResources, headroomScalarLimit);
+        nonQuotaGuaranteeResources = shrinkResources(
+            nonQuotaGuaranteeResources,
+            ResourceQuantities::fromScalarResources(surplusHeadroom.scalars()));
 
         toAllocate += nonQuotaGuaranteeResources;