Revert "Merge pull request #20302 from vespa-engine/revert-20298-bratseth/autoscaling-in-dev"

This reverts commit aa3ffac0caaba2c60fabc585be8376cfe132c17d, reversing
changes made to 318edd10866b25b06419ed6069227eafbe63d685.

1 files changed, 16 insertions, 10 deletions

diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/AllocatableClusterResources.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/AllocatableClusterResources.java
index f1e707be7b4..078b0621a99 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/AllocatableClusterResources.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/AllocatableClusterResources.java
@@ -8,6 +8,7 @@ import com.yahoo.config.provision.NodeResources;
 import com.yahoo.vespa.hosted.provision.Node;
 import com.yahoo.vespa.hosted.provision.NodeList;
 import com.yahoo.vespa.hosted.provision.NodeRepository;
+import com.yahoo.vespa.hosted.provision.provisioning.CapacityPolicies;
 import com.yahoo.vespa.hosted.provision.provisioning.NodeResourceLimits;
 
 import java.util.List;
@@ -54,14 +55,14 @@ public class AllocatableClusterResources {
 
     public AllocatableClusterResources(ClusterResources realResources,
                                        NodeResources advertisedResources,
-                                       NodeResources idealResources,
+                                       ClusterResources idealResources,
                                        ClusterSpec clusterSpec) {
         this.nodes = realResources.nodes();
         this.groups = realResources.groups();
         this.realResources = realResources.nodeResources();
         this.advertisedResources = advertisedResources;
         this.clusterSpec = clusterSpec;
-        this.fulfilment = fulfilment(realResources.nodeResources(), idealResources);
+        this.fulfilment = fulfilment(realResources, idealResources);
     }
 
     /**
@@ -99,10 +100,10 @@ public class AllocatableClusterResources {
      */
     public double fulfilment() { return fulfilment; }
 
-    private static double fulfilment(NodeResources realResources, NodeResources idealResources) {
-        double vcpuFulfilment     = Math.min(1, realResources.vcpu()     / idealResources.vcpu());
-        double memoryGbFulfilment = Math.min(1, realResources.memoryGb() / idealResources.memoryGb());
-        double diskGbFulfilment   = Math.min(1, realResources.diskGb()   / idealResources.diskGb());
+    private static double fulfilment(ClusterResources realResources, ClusterResources idealResources) {
+        double vcpuFulfilment     = Math.min(1, realResources.totalResources().vcpu()     / idealResources.totalResources().vcpu());
+        double memoryGbFulfilment = Math.min(1, realResources.totalResources().memoryGb() / idealResources.totalResources().memoryGb());
+        double diskGbFulfilment   = Math.min(1, realResources.totalResources().diskGb()   / idealResources.totalResources().diskGb());
         return (vcpuFulfilment + memoryGbFulfilment + diskGbFulfilment) / 3;
     }
 
@@ -138,21 +139,25 @@ public class AllocatableClusterResources {
     public static Optional<AllocatableClusterResources> from(ClusterResources wantedResources,
                                                              ClusterSpec clusterSpec,
                                                              Limits applicationLimits,
+                                                             boolean required,
                                                              NodeList hosts,
                                                              NodeRepository nodeRepository) {
+        var capacityPolicies = new CapacityPolicies(nodeRepository);
         var systemLimits = new NodeResourceLimits(nodeRepository);
         boolean exclusive = clusterSpec.isExclusive();
+        int actualNodes = capacityPolicies.decideSize(wantedResources.nodes(), required, true, false, clusterSpec);
         if ( !clusterSpec.isExclusive() && !nodeRepository.zone().getCloud().dynamicProvisioning()) {
             // We decide resources: Add overhead to what we'll request (advertised) to make sure real becomes (at least) cappedNodeResources
             var advertisedResources = nodeRepository.resourcesCalculator().realToRequest(wantedResources.nodeResources(), exclusive);
             advertisedResources = systemLimits.enlargeToLegal(advertisedResources, clusterSpec.type(), exclusive); // Ask for something legal
             advertisedResources = applicationLimits.cap(advertisedResources); // Overrides other conditions, even if it will then fail
+            advertisedResources = capacityPolicies.decideNodeResources(advertisedResources, required, clusterSpec); // Adjust to what we can request
             var realResources = nodeRepository.resourcesCalculator().requestToReal(advertisedResources, exclusive); // What we'll really get
             if ( ! systemLimits.isWithinRealLimits(realResources, clusterSpec.type())) return Optional.empty();
             if (matchesAny(hosts, advertisedResources))
-                    return Optional.of(new AllocatableClusterResources(wantedResources.with(realResources),
+                    return Optional.of(new AllocatableClusterResources(wantedResources.withNodes(actualNodes).with(realResources),
                                                                        advertisedResources,
-                                                                       wantedResources.nodeResources(),
+                                                                       wantedResources,
                                                                        clusterSpec));
             else
                 return Optional.empty();
@@ -163,6 +168,7 @@ public class AllocatableClusterResources {
             for (Flavor flavor : nodeRepository.flavors().getFlavors()) {
                 // Flavor decide resources: Real resources are the worst case real resources we'll get if we ask for these advertised resources
                 NodeResources advertisedResources = nodeRepository.resourcesCalculator().advertisedResourcesOf(flavor);
+                advertisedResources = capacityPolicies.decideNodeResources(advertisedResources, required, clusterSpec); // Adjust to what we can get
                 NodeResources realResources = nodeRepository.resourcesCalculator().requestToReal(advertisedResources, exclusive);
 
                 // Adjust where we don't need exact match to the flavor
@@ -178,9 +184,9 @@ public class AllocatableClusterResources {
 
                 if ( ! between(applicationLimits.min().nodeResources(), applicationLimits.max().nodeResources(), advertisedResources)) continue;
                 if ( ! systemLimits.isWithinRealLimits(realResources, clusterSpec.type())) continue;
-                var candidate = new AllocatableClusterResources(wantedResources.with(realResources),
+                var candidate = new AllocatableClusterResources(wantedResources.withNodes(actualNodes).with(realResources),
                                                                 advertisedResources,
-                                                                wantedResources.nodeResources(),
+                                                                wantedResources,
                                                                 clusterSpec);
                 if (best.isEmpty() || candidate.preferableTo(best.get()))
                     best = Optional.of(candidate);