Merge pull request #13402 from vespa-engine/bratseth/lowestRealResourcesAllocating

Bratseth/lowest real resources allocating

17 files changed, 262 insertions, 125 deletions

diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/applications/Application.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/applications/Application.java
index 3a3d3e4ec2e..e9e91910281 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/applications/Application.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/applications/Application.java
@@ -53,12 +53,12 @@ public class Application {
      * Returns an application with the given cluster having the min and max resource limits of the given cluster.
      * If the cluster has a target which is not inside the new limits, the target is removed.
      */
-    public Application withClusterLimits(ClusterSpec.Id id, ClusterResources min, ClusterResources max) {
+    public Application withCluster(ClusterSpec.Id id, boolean exclusive, ClusterResources min, ClusterResources max) {
         Cluster cluster = clusters.get(id);
         if (cluster == null)
-            cluster = new Cluster(id, min, max, Optional.empty(), Optional.empty());
+            cluster = new Cluster(id, exclusive, min, max, Optional.empty(), Optional.empty());
         else
-            cluster = cluster.withLimits(min, max);
+            cluster = cluster.withConfiguration(exclusive, min, max);
         return with(cluster);
     }
 
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/applications/Cluster.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/applications/Cluster.java
index 847ec1290f6..3aae47a9088 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/applications/Cluster.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/applications/Cluster.java
@@ -19,16 +19,19 @@ import java.util.Optional;
 public class Cluster {
 
     private final ClusterSpec.Id id;
+    private final boolean exclusive;
     private final ClusterResources min, max;
     private final Optional<ClusterResources> suggested;
     private final Optional<ClusterResources> target;
 
     public Cluster(ClusterSpec.Id id,
+                   boolean exclusive,
                    ClusterResources minResources,
                    ClusterResources maxResources,
                    Optional<ClusterResources> suggestedResources,
                    Optional<ClusterResources> targetResources) {
         this.id = Objects.requireNonNull(id);
+        this.exclusive = exclusive;
         this.min = Objects.requireNonNull(minResources);
         this.max = Objects.requireNonNull(maxResources);
         this.suggested = Objects.requireNonNull(suggestedResources);
@@ -47,6 +50,9 @@ public class Cluster {
     /** Returns the configured maximal resources in this cluster */
     public ClusterResources maxResources() { return max; }
 
+    /** Returns whether the nodes allocated to this cluster must be on host exclusively dedicated to this application */
+    public boolean exclusive() { return exclusive; }
+
     /**
      * Returns the computed resources (between min and max, inclusive) this cluster should
      * have allocated at the moment (whether or not it actually has it),
@@ -60,16 +66,16 @@ public class Cluster {
      */
     public Optional<ClusterResources> suggestedResources() { return suggested; }
 
-    public Cluster withLimits(ClusterResources min, ClusterResources max) {
-        return new Cluster(id, min, max, suggested, target);
+    public Cluster withConfiguration(boolean exclusive, ClusterResources min, ClusterResources max) {
+        return new Cluster(id, exclusive, min, max, suggested, target);
     }
 
     public Cluster withSuggested(Optional<ClusterResources> suggested) {
-        return new Cluster(id, min, max, suggested, target);
+        return new Cluster(id, exclusive, min, max, suggested, target);
     }
 
     public Cluster withTarget(Optional<ClusterResources> target) {
-        return new Cluster(id, min, max, suggested, target);
+        return new Cluster(id, exclusive, min, max, suggested, target);
     }
 
     @Override
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 1637d99a07a..b5a5d1e06b4 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
@@ -33,19 +33,19 @@ public class AllocatableClusterResources {
 
     /** Fake allocatable resources from requested capacity */
     public AllocatableClusterResources(ClusterResources requested, ClusterSpec.Type clusterType) {
-        this.advertisedResources = requested.nodeResources();
-        this.realResources = requested.nodeResources(); // we don't know
         this.nodes = requested.nodes();
         this.groups = requested.groups();
+        this.realResources = requested.nodeResources(); // we don't know
+        this.advertisedResources = requested.nodeResources();
         this.clusterType = clusterType;
         this.fulfilment = 1;
     }
 
     public AllocatableClusterResources(List<Node> nodes, NodeRepository nodeRepository) {
-        this.advertisedResources = nodes.get(0).flavor().resources();
-        this.realResources = nodeRepository.resourcesCalculator().realResourcesOf(nodes.get(0), nodeRepository);
         this.nodes = nodes.size();
         this.groups = (int)nodes.stream().map(node -> node.allocation().get().membership().cluster().group()).distinct().count();
+        this.realResources = nodeRepository.resourcesCalculator().realResourcesOf(nodes.get(0), nodeRepository);
+        this.advertisedResources = nodes.get(0).flavor().resources();
         this.clusterType = nodes.get(0).allocation().get().membership().cluster().type();
         this.fulfilment = 1;
     }
@@ -54,23 +54,10 @@ public class AllocatableClusterResources {
                                        NodeResources advertisedResources,
                                        NodeResources idealResources,
                                        ClusterSpec.Type clusterType) {
-        this.realResources = realResources.nodeResources();
-        this.advertisedResources = advertisedResources;
         this.nodes = realResources.nodes();
         this.groups = realResources.groups();
-        this.clusterType = clusterType;
-        this.fulfilment = fulfilment(realResources.nodeResources(), idealResources);
-    }
-
-    public AllocatableClusterResources(ClusterResources realResources,
-                                       Flavor flavor,
-                                       NodeResources idealResources,
-                                       ClusterSpec.Type clusterType,
-                                       HostResourcesCalculator calculator) {
         this.realResources = realResources.nodeResources();
-        this.advertisedResources = calculator.advertisedResourcesOf(flavor);
-        this.nodes = realResources.nodes();
-        this.groups = realResources.groups();
+        this.advertisedResources = advertisedResources;
         this.clusterType = clusterType;
         this.fulfilment = fulfilment(realResources.nodeResources(), idealResources);
     }
@@ -127,7 +114,7 @@ public class AllocatableClusterResources {
     public String toString() {
         return nodes + " nodes " +
                ( groups > 1 ? "(in " + groups + " groups) " : "" ) +
-               "with " + realResources() +
+               "with " + advertisedResources() +
                " at cost $" + cost() +
                (fulfilment < 1.0 ? " (fulfilment " + fulfilment + ")" : "");
     }
@@ -135,31 +122,39 @@ public class AllocatableClusterResources {
     /**
      * Returns the best matching allocatable node resources given ideal node resources,
      * or empty if none available within the limits.
+     *
+     * @param resources the real resources that should ideally be allocated
+     * @param exclusive whether resources should be allocated on entire hosts
+     *        (in which case the allocated resources will be all the real resources of the host
+     *         and limits are required to encompass the full resources of candidate host flavors)
      */
     public static Optional<AllocatableClusterResources> from(ClusterResources resources,
+                                                             boolean exclusive,
                                                              ClusterSpec.Type clusterType,
                                                              Limits limits,
                                                              NodeRepository nodeRepository) {
         NodeResources cappedNodeResources = limits.cap(resources.nodeResources());
         cappedNodeResources = new NodeResourceLimits(nodeRepository).enlargeToLegal(cappedNodeResources, clusterType);
 
-        if (nodeRepository.zone().getCloud().allowHostSharing()) {
-            // return the requested resources, or empty if they cannot fit on existing hosts
+        if ( !exclusive && nodeRepository.zone().getCloud().allowHostSharing()) { // Check if any flavor can fit these hosts
+            // We decide resources: Add overhead to what we'll request (advertised) to make sure real becomes (at least) cappedNodeResources
+            NodeResources realResources = cappedNodeResources;
+            NodeResources advertisedResources = nodeRepository.resourcesCalculator().realToRequest(realResources);
             for (Flavor flavor : nodeRepository.flavors().getFlavors()) {
-                if (flavor.resources().satisfies(cappedNodeResources))
-                    return Optional.of(new AllocatableClusterResources(resources.with(cappedNodeResources),
-                                                                       cappedNodeResources,
+                if (flavor.resources().satisfies(advertisedResources))
+                    return Optional.of(new AllocatableClusterResources(resources.with(realResources),
+                                                                       advertisedResources,
                                                                        resources.nodeResources(),
                                                                        clusterType));
             }
             return Optional.empty();
         }
-        else {
-            // return the cheapest flavor satisfying the target resources, if any
+        else { // Return the cheapest flavor satisfying the requested resources, if any
             Optional<AllocatableClusterResources> best = Optional.empty();
             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);
-                NodeResources realResources = flavor.resources();
+                NodeResources realResources = nodeRepository.resourcesCalculator().requestToReal(advertisedResources);
 
                 // Adjust where we don't need exact match to the flavor
                 if (flavor.resources().storageType() == NodeResources.StorageType.remote) {
@@ -172,7 +167,6 @@ public class AllocatableClusterResources {
                 }
 
                 if ( ! between(limits.min().nodeResources(), limits.max().nodeResources(), advertisedResources)) continue;
-
                 var candidate = new AllocatableClusterResources(resources.with(realResources),
                                                                 advertisedResources,
                                                                 resources.nodeResources(),
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/AllocationOptimizer.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/AllocationOptimizer.java
index 475f2feaebd..d2589b15421 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/AllocationOptimizer.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/AllocationOptimizer.java
@@ -38,7 +38,8 @@ public class AllocationOptimizer {
      */
     public Optional<AllocatableClusterResources> findBestAllocation(ResourceTarget target,
                                                                     AllocatableClusterResources current,
-                                                                    Limits limits) {
+                                                                    Limits limits,
+                                                                    boolean exclusive) {
         if (limits.isEmpty())
             limits = Limits.of(new ClusterResources(minimumNodes,    1, NodeResources.unspecified()),
                                new ClusterResources(maximumNodes, maximumNodes, NodeResources.unspecified()));
@@ -57,7 +58,7 @@ public class AllocationOptimizer {
                                                              groups,
                                                              nodeResourcesWith(nodesAdjustedForRedundancy, groupsAdjustedForRedundancy, limits, current, target));
 
-                var allocatableResources = AllocatableClusterResources.from(next, current.clusterType(), limits, nodeRepository);
+                var allocatableResources = AllocatableClusterResources.from(next, exclusive, current.clusterType(), limits, nodeRepository);
                 if (allocatableResources.isEmpty()) continue;
                 if (bestAllocation.isEmpty() || allocatableResources.get().preferableTo(bestAllocation.get()))
                     bestAllocation = allocatableResources;
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/Autoscaler.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/Autoscaler.java
index 8930bf34f4a..27731159e9f 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/Autoscaler.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/Autoscaler.java
@@ -53,7 +53,7 @@ public class Autoscaler {
      * @return a new suggested allocation for this cluster, or empty if it should not be rescaled at this time
      */
     public Optional<ClusterResources> suggest(Cluster cluster, List<Node> clusterNodes) {
-        return autoscale(clusterNodes, Limits.empty())
+        return autoscale(clusterNodes, Limits.empty(), cluster.exclusive())
                        .map(AllocatableClusterResources::toAdvertisedClusterResources);
 
     }
@@ -66,11 +66,11 @@ public class Autoscaler {
      */
     public Optional<ClusterResources> autoscale(Cluster cluster, List<Node> clusterNodes) {
         if (cluster.minResources().equals(cluster.maxResources())) return Optional.empty(); // Shortcut
-        return autoscale(clusterNodes, Limits.of(cluster))
+        return autoscale(clusterNodes, Limits.of(cluster), cluster.exclusive())
                        .map(AllocatableClusterResources::toAdvertisedClusterResources);
     }
 
-    private Optional<AllocatableClusterResources> autoscale(List<Node> clusterNodes, Limits limits) {
+    private Optional<AllocatableClusterResources> autoscale(List<Node> clusterNodes, Limits limits, boolean exclusive) {
         if (unstable(clusterNodes)) return Optional.empty();
 
         ClusterSpec.Type clusterType = clusterNodes.get(0).allocation().get().membership().cluster().type();
@@ -82,7 +82,7 @@ public class Autoscaler {
         var target = ResourceTarget.idealLoad(cpuLoad.get(), memoryLoad.get(), diskLoad.get(), currentAllocation);
 
         Optional<AllocatableClusterResources> bestAllocation =
-                allocationOptimizer.findBestAllocation(target, currentAllocation, limits);
+                allocationOptimizer.findBestAllocation(target, currentAllocation, limits, exclusive);
         if (bestAllocation.isEmpty()) return Optional.empty();
         if (similar(bestAllocation.get(), currentAllocation)) return Optional.empty();
         return bestAllocation;
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/ResourceTarget.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/ResourceTarget.java
index 9359d8251f7..f7c2a51436a 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/ResourceTarget.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/autoscale/ResourceTarget.java
@@ -11,7 +11,7 @@ public class ResourceTarget {
 
     private final boolean adjustForRedundancy;
 
-    /** The target resources per node, assuming the node assignment in current */
+    /** The target resources per node, assuming the node assignment where this was decided */
     private final double cpu, memory, disk;
 
     private ResourceTarget(double cpu, double memory, double disk, boolean adjustForRedundancy) {
@@ -33,6 +33,13 @@ public class ResourceTarget {
     /** Returns the target disk per node, in terms of the current allocation */
     public double nodeDisk() { return disk; }
 
+    @Override
+    public String toString() {
+        return "target " +
+               (adjustForRedundancy ? "(with redundancy adjustment) " : "") +
+               "[vcpu " + cpu + ", memoryGb " + memory + ", diskGb " + disk + "]";
+    }
+
     private static double nodeUsage(Resource resource, double load, AllocatableClusterResources current) {
         return load * resource.valueFrom(current.realResources());
     }
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/persistence/ApplicationSerializer.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/persistence/ApplicationSerializer.java
index b1453a9729a..3464e9dd881 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/persistence/ApplicationSerializer.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/persistence/ApplicationSerializer.java
@@ -35,6 +35,7 @@ public class ApplicationSerializer {
 
     private static final String idKey = "id";
     private static final String clustersKey = "clusters";
+    private static final String exclusiveKey = "exclusive";
     private static final String minResourcesKey = "min";
     private static final String maxResourcesKey = "max";
     private static final String suggestedResourcesKey = "suggested";
@@ -80,6 +81,7 @@ public class ApplicationSerializer {
     }
 
     private static void toSlime(Cluster cluster, Cursor clusterObject) {
+        clusterObject.setBool(exclusiveKey, cluster.exclusive());
         toSlime(cluster.minResources(), clusterObject.setObject(minResourcesKey));
         toSlime(cluster.maxResources(), clusterObject.setObject(maxResourcesKey));
         cluster.suggestedResources().ifPresent(suggested -> toSlime(suggested, clusterObject.setObject(suggestedResourcesKey)));
@@ -88,6 +90,7 @@ public class ApplicationSerializer {
 
     private static Cluster clusterFromSlime(String id, Inspector clusterObject) {
         return new Cluster(ClusterSpec.Id.from(id),
+                           clusterObject.field(exclusiveKey).asBool(),
                            clusterResourcesFromSlime(clusterObject.field(minResourcesKey)),
                            clusterResourcesFromSlime(clusterObject.field(maxResourcesKey)),
                            optionalClusterResourcesFromSlime(clusterObject.field(suggestedResourcesKey)),
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/EmptyProvisionServiceProvider.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/EmptyProvisionServiceProvider.java
index da54d89b4e5..e4b1e0fcbc0 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/EmptyProvisionServiceProvider.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/EmptyProvisionServiceProvider.java
@@ -34,14 +34,17 @@ public class EmptyProvisionServiceProvider implements ProvisionServiceProvider {
     private static class IdentityHostResourcesCalculator implements HostResourcesCalculator {
 
         @Override
-        public NodeResources realResourcesOf(Node node, NodeRepository repository) {
-            return node.flavor().resources();
-        }
+        public NodeResources realResourcesOf(Node node, NodeRepository repository) { return node.flavor().resources(); }
 
         @Override
-        public NodeResources advertisedResourcesOf(Flavor flavor) {
-            return flavor.resources();
-        }
+        public NodeResources advertisedResourcesOf(Flavor flavor) { return flavor.resources(); }
+
+        @Override
+        public NodeResources requestToReal(NodeResources resources) { return resources; }
+
+        @Override
+        public NodeResources realToRequest(NodeResources resources) { return resources; }
 
     }
+
 }
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/HostResourcesCalculator.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/HostResourcesCalculator.java
index 096e58e963e..a071fb25da2 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/HostResourcesCalculator.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/HostResourcesCalculator.java
@@ -16,10 +16,22 @@ import com.yahoo.vespa.hosted.provision.NodeRepository;
  */
 public interface HostResourcesCalculator {
 
-    /** Nodes use advertised resources. This returns the real resources for the node. */
+    /** Returns the real resources available on a node */
     NodeResources realResourcesOf(Node node, NodeRepository nodeRepository);
 
-    /** Flavors use real resources. This returns the advertised resources of the flavor. */
+    /** Returns the advertised resources of a flavor */
     NodeResources advertisedResourcesOf(Flavor flavor);
 
+    /**
+     * Used with exclusive hosts:
+     * Returns the lowest possible real resources we'll get if requesting the given advertised resources
+     */
+    NodeResources requestToReal(NodeResources advertisedResources);
+
+    /**
+     * Used with shared hosts:
+     * Returns the advertised resources we need to request to be sure to get at least the given real resources.
+     */
+    NodeResources realToRequest(NodeResources realResources);
+
 }
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeRepositoryProvisioner.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeRepositoryProvisioner.java
index ccf08fdef48..433a69a063e 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeRepositoryProvisioner.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeRepositoryProvisioner.java
@@ -144,7 +144,7 @@ public class NodeRepositoryProvisioner implements Provisioner {
     private ClusterResources decideTargetResources(ApplicationId applicationId, ClusterSpec clusterSpec, Capacity requested) {
         try (Mutex lock = nodeRepository.lock(applicationId)) {
             Application application = nodeRepository.applications().get(applicationId).orElse(new Application(applicationId));
-            application = application.withClusterLimits(clusterSpec.id(), requested.minResources(), requested.maxResources());
+            application = application.withCluster(clusterSpec.id(), clusterSpec.isExclusive(), requested.minResources(), requested.maxResources());
             nodeRepository.applications().put(application, lock);
             return application.clusters().get(clusterSpec.id()).targetResources()
                     .orElseGet(() -> currentResources(applicationId, clusterSpec, requested));
@@ -163,15 +163,15 @@ public class NodeRepositoryProvisioner implements Provisioner {
         AllocatableClusterResources currentResources =
                 nodes.isEmpty() ? new AllocatableClusterResources(requested.minResources(), clusterSpec.type()) // new deployment: Use min
                                 : new AllocatableClusterResources(nodes, nodeRepository);
-        return within(Limits.of(requested), currentResources);
+        return within(Limits.of(requested), clusterSpec.isExclusive(), currentResources);
     }
 
     /** Make the minimal adjustments needed to the current resources to stay within the limits */
-    private ClusterResources within(Limits limits, AllocatableClusterResources current) {
+    private ClusterResources within(Limits limits, boolean exclusive, AllocatableClusterResources current) {
         if (limits.isEmpty()) return current.toAdvertisedClusterResources();
         if (limits.min().equals(limits.max())) return limits.min();
 
-        return allocationOptimizer.findBestAllocation(ResourceTarget.preserve(current), current, limits)
+        return allocationOptimizer.findBestAllocation(ResourceTarget.preserve(current), current, limits, exclusive)
                                   .orElseThrow(() -> new IllegalArgumentException("No allocation possible within " + limits))
                                   .toAdvertisedClusterResources();
     }
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingIntegrationTest.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingIntegrationTest.java
index 032375943c8..e65abaa21ec 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingIntegrationTest.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingIntegrationTest.java
@@ -56,7 +56,7 @@ public class AutoscalingIntegrationTest {
         ClusterResources max = new ClusterResources(2, 1, nodes);
 
         Application application = tester.nodeRepository().applications().get(application1).orElse(new Application(application1))
-                                        .withClusterLimits(cluster1.id(), min, max);
+                                        .withCluster(cluster1.id(), false, min, max);
         tester.nodeRepository().applications().put(application, tester.nodeRepository().lock(application1));
         var scaledResources = autoscaler.suggest(application.clusters().get(cluster1.id()),
                                                  tester.nodeRepository().getNodes(application1));
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingTest.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingTest.java
index 08e4237fe00..3a87b5967fb 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingTest.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingTest.java
@@ -11,12 +11,16 @@ import com.yahoo.config.provision.NodeResources;
 import com.yahoo.config.provision.RegionName;
 import com.yahoo.config.provision.SystemName;
 import com.yahoo.config.provision.Zone;
+import com.yahoo.vespa.hosted.provision.Node;
+import com.yahoo.vespa.hosted.provision.NodeRepository;
+import com.yahoo.vespa.hosted.provision.provisioning.HostResourcesCalculator;
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
+import static com.yahoo.config.provision.NodeResources.StorageType.local;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
@@ -26,7 +30,7 @@ import static org.junit.Assert.assertTrue;
 public class AutoscalingTest {
 
     @Test
-    public void testAutoscalingSingleContentGroup() {
+    public void test_autoscaling_single_content_group() {
         NodeResources hostResources = new NodeResources(3, 100, 100, 1);
         ClusterResources min = new ClusterResources( 2, 1,
                                                      new NodeResources(1, 1, 1, 1, NodeResources.DiskSpeed.any));
@@ -68,7 +72,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingHandlesDiskSettingChanges() {
+    public void autoscaling_handles_disk_setting_changes() {
         NodeResources hostResources = new NodeResources(3, 100, 100, 1, NodeResources.DiskSpeed.slow);
         AutoscalingTester tester = new AutoscalingTester(hostResources);
 
@@ -98,7 +102,7 @@ public class AutoscalingTest {
 
     /** We prefer fewer nodes for container clusters as (we assume) they all use the same disk and memory */
     @Test
-    public void testAutoscalingSingleContainerGroup() {
+    public void test_autoscaling_single_container_group() {
         NodeResources resources = new NodeResources(3, 100, 100, 1);
         ClusterResources min = new ClusterResources( 2, 1, new NodeResources(1, 1, 1, 1));
         ClusterResources max = new ClusterResources(20, 1, new NodeResources(100, 1000, 1000, 1));
@@ -125,7 +129,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingRespectsUpperLimit() {
+    public void autoscaling_respects_upper_limit() {
         NodeResources hostResources = new NodeResources(3, 100, 100, 1);
         ClusterResources min = new ClusterResources( 2, 1, new NodeResources(1, 1, 1, 1));
         ClusterResources max = new ClusterResources( 6, 1, new NodeResources(2.4, 78, 79, 1));
@@ -146,7 +150,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingRespectsLowerLimit() {
+    public void autoscaling_respects_lower_limit() {
         NodeResources resources = new NodeResources(3, 100, 100, 1);
         ClusterResources min = new ClusterResources( 4, 1, new NodeResources(1.8, 7.4, 8.5, 1));
         ClusterResources max = new ClusterResources( 6, 1, new NodeResources(2.4, 78, 79, 1));
@@ -166,7 +170,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingRespectsGroupLimit() {
+    public void autoscaling_respects_group_limit() {
         NodeResources hostResources = new NodeResources(30.0, 100, 100, 1);
         ClusterResources min = new ClusterResources( 2, 2, new NodeResources(1, 1, 1, 1));
         ClusterResources max = new ClusterResources(18, 6, new NodeResources(100, 1000, 1000, 1));
@@ -184,7 +188,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingLimitsWhenMinEqualsMax() {
+    public void test_autoscaling_limits_when_min_equals_xax() {
         NodeResources resources = new NodeResources(3, 100, 100, 1);
         ClusterResources min = new ClusterResources( 2, 1, new NodeResources(1, 1, 1, 1));
         ClusterResources max = min;
@@ -200,7 +204,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testSuggestionsIgnoresLimits() {
+    public void suggestions_ignores_limits() {
         NodeResources resources = new NodeResources(3, 100, 100, 1);
         ClusterResources min = new ClusterResources( 2, 1, new NodeResources(1, 1, 1, 1));
         ClusterResources max = min;
@@ -218,7 +222,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingGroupSize1() {
+    public void test_autoscaling_group_size_1() {
         NodeResources resources = new NodeResources(3, 100, 100, 1);
         ClusterResources min = new ClusterResources( 2, 2, new NodeResources(1, 1, 1, 1));
         ClusterResources max = new ClusterResources(20, 20, new NodeResources(100, 1000, 1000, 1));
@@ -236,7 +240,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingGroupSizeByCpu() {
+    public void test_autoscalinggroupsize_by_cpu() {
         NodeResources resources = new NodeResources(3, 100, 100, 1);
         ClusterResources min = new ClusterResources( 3, 1, new NodeResources(1, 1, 1, 1));
         ClusterResources max = new ClusterResources(21, 7, new NodeResources(100, 1000, 1000, 1));
@@ -254,7 +258,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingGroupSize() {
+    public void test_autoscaling_group_size() {
         NodeResources hostResources = new NodeResources(100, 1000, 1000, 100);
         ClusterResources min = new ClusterResources( 3, 2, new NodeResources(1, 1, 1, 1));
         ClusterResources max = new ClusterResources(30, 30, new NodeResources(100, 100, 1000, 1));
@@ -272,7 +276,7 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingAvoidsIllegalConfigurations() {
+    public void autoscaling_avoids_illegal_configurations() {
         NodeResources resources = new NodeResources(3, 100, 100, 1);
         ClusterResources min = new ClusterResources( 2, 1, new NodeResources(1, 1, 1, 1));
         ClusterResources max = new ClusterResources(20, 1, new NodeResources(100, 1000, 1000, 1));
@@ -290,7 +294,44 @@ public class AutoscalingTest {
     }
 
     @Test
-    public void testAutoscalingAws() {
+    public void real_resources_are_taken_into_account() {
+        NodeResources hostResources = new NodeResources(60, 100, 1000, 10);
+        ClusterResources min = new ClusterResources(2, 1, new NodeResources( 2,  20,  200, 1));
+        ClusterResources max = new ClusterResources(4, 1, new NodeResources(60, 100, 1000, 1));
+
+        { // No memory tax
+            AutoscalingTester tester = new AutoscalingTester(hostResources, new OnlySubtractingWhenForecastingCalculator(0));
+
+            ApplicationId application1 = tester.applicationId("app1");
+            ClusterSpec cluster1 = tester.clusterSpec(ClusterSpec.Type.content, "cluster1");
+
+            tester.deploy(application1, cluster1, min);
+            tester.addMeasurements(Resource.cpu, 1.0f, 1000, application1);
+            tester.addMeasurements(Resource.memory, 1.0f, 1000, application1);
+            tester.addMeasurements(Resource.disk, 0.7f, 1000, application1);
+            tester.assertResources("Scaling up",
+                                   4, 1, 7.0, 20, 200,
+                                   tester.autoscale(application1, cluster1.id(), min, max));
+        }
+
+        { // 15 Gb memory tax
+            AutoscalingTester tester = new AutoscalingTester(hostResources, new OnlySubtractingWhenForecastingCalculator(15));
+
+            ApplicationId application1 = tester.applicationId("app1");
+            ClusterSpec cluster1 = tester.clusterSpec(ClusterSpec.Type.content, "cluster1");
+
+            tester.deploy(application1, cluster1, min);
+            tester.addMeasurements(Resource.cpu, 1.0f, 1000, application1);
+            tester.addMeasurements(Resource.memory, 1.0f, 1000, application1);
+            tester.addMeasurements(Resource.disk, 0.7f, 1000, application1);
+            tester.assertResources("Scaling up",
+                                   4, 1, 7.0, 35, 200,
+                                   tester.autoscale(application1, cluster1.id(), min, max));
+        }
+    }
+
+    @Test
+    public void test_autoscaling_without_host_sharing() {
         ClusterResources min = new ClusterResources( 2, 1, new NodeResources(1, 1, 1, 1));
         ClusterResources max = new ClusterResources(20, 1, new NodeResources(100, 1000, 1000, 1));
         List<Flavor> flavors = new ArrayList<>();
@@ -325,4 +366,40 @@ public class AutoscalingTest {
                                tester.autoscale(application1, cluster1.id(), min, max));
     }
 
+    /**
+     * This calculator subtracts the memory tax when forecasting overhead, but not when actually
+     * returning information about nodes. This is allowed because the forecast is a *worst case*.
+     * It is useful here because it ensures that we end up with the same real (and therefore target)
+     * resources regardless of tax which makes it easier to compare behavior with different tax levels.
+     */
+    private static class OnlySubtractingWhenForecastingCalculator implements HostResourcesCalculator {
+
+        private final int memoryTaxGb;
+
+        public OnlySubtractingWhenForecastingCalculator(int memoryTaxGb) {
+            this.memoryTaxGb = memoryTaxGb;
+        }
+
+        @Override
+        public NodeResources realResourcesOf(Node node, NodeRepository nodeRepository) {
+            return node.flavor().resources();
+        }
+
+        @Override
+        public NodeResources advertisedResourcesOf(Flavor flavor) {
+            return flavor.resources();
+        }
+
+        @Override
+        public NodeResources requestToReal(NodeResources resources) {
+            return resources.withMemoryGb(resources.memoryGb() - memoryTaxGb);
+        }
+
+        @Override
+        public NodeResources realToRequest(NodeResources resources) {
+            return resources.withMemoryGb(resources.memoryGb() + memoryTaxGb);
+        }
+
+    }
+
 }
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingTester.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingTester.java
index 79d6b20dce8..963ca0d4341 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingTester.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/AutoscalingTester.java
@@ -32,6 +32,7 @@ import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 
+import static com.yahoo.config.provision.NodeResources.StorageType.local;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
@@ -44,15 +45,24 @@ class AutoscalingTester {
 
     /** Creates an autoscaling tester with a single host type ready */
     public AutoscalingTester(NodeResources hostResources) {
-        this(new Zone(Environment.prod, RegionName.from("us-east")), List.of(new Flavor("hostFlavor", hostResources)));
+        this(hostResources, null);
+    }
+
+    public AutoscalingTester(NodeResources hostResources, HostResourcesCalculator resourcesCalculator) {
+        this(new Zone(Environment.prod, RegionName.from("us-east")), List.of(new Flavor("hostFlavor", hostResources)), resourcesCalculator);
         provisioningTester.makeReadyNodes(20, "hostFlavor", NodeType.host, 8);
         provisioningTester.deployZoneApp();
     }
 
     public AutoscalingTester(Zone zone, List<Flavor> flavors) {
+        this(zone, flavors, new MockHostResourcesCalculator(zone));
+    }
+
+    private AutoscalingTester(Zone zone, List<Flavor> flavors,
+                              HostResourcesCalculator resourcesCalculator) {
         provisioningTester = new ProvisioningTester.Builder().zone(zone)
                                                              .flavors(flavors)
-                                                             .resourcesCalculator(new MockHostResourcesCalculator(zone))
+                                                             .resourcesCalculator(resourcesCalculator)
                                                              .hostProvisioner(new MockHostProvisioner(flavors))
                                                              .build();
 
@@ -147,7 +157,7 @@ class AutoscalingTester {
     public Optional<ClusterResources> autoscale(ApplicationId applicationId, ClusterSpec.Id clusterId,
                                                            ClusterResources min, ClusterResources max) {
         Application application = nodeRepository().applications().get(applicationId).orElse(new Application(applicationId))
-                                                  .withClusterLimits(clusterId, min, max);
+                                                  .withCluster(clusterId, false, min, max);
         nodeRepository().applications().put(application, nodeRepository().lock(applicationId));
         return autoscaler.autoscale(application.clusters().get(clusterId),
                                     nodeRepository().getNodes(applicationId, Node.State.active));
@@ -156,7 +166,7 @@ class AutoscalingTester {
     public Optional<ClusterResources> suggest(ApplicationId applicationId, ClusterSpec.Id clusterId,
                                                            ClusterResources min, ClusterResources max) {
         Application application = nodeRepository().applications().get(applicationId).orElse(new Application(applicationId))
-                                                  .withClusterLimits(clusterId, min, max);
+                                                  .withCluster(clusterId, false, min, max);
         nodeRepository().applications().put(application, nodeRepository().lock(applicationId));
         return autoscaler.suggest(application.clusters().get(clusterId),
                                   nodeRepository().getNodes(applicationId, Node.State.active));
@@ -210,6 +220,16 @@ class AutoscalingTester {
                 return flavor.resources();
         }
 
+        @Override
+        public NodeResources requestToReal(NodeResources resources) {
+            return resources.withMemoryGb(resources.memoryGb() - 3);
+        }
+
+        @Override
+        public NodeResources realToRequest(NodeResources resources) {
+            return resources.withMemoryGb(resources.memoryGb() + 3);
+        }
+
     }
 
     private class MockHostProvisioner implements HostProvisioner {
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/persistence/ApplicationSerializerTest.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/persistence/ApplicationSerializerTest.java
index c50805eebb8..598831d1eeb 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/persistence/ApplicationSerializerTest.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/persistence/ApplicationSerializerTest.java
@@ -26,11 +26,13 @@ public class ApplicationSerializerTest {
     public void testApplicationSerialization() {
         List<Cluster> clusters = new ArrayList<>();
         clusters.add(new Cluster(ClusterSpec.Id.from("c1"),
+                                 false,
                                  new ClusterResources( 8, 4, new NodeResources(1, 2,  3,  4)),
                                  new ClusterResources(12, 6, new NodeResources(3, 6, 21, 24)),
                                  Optional.empty(),
                                  Optional.empty()));
         clusters.add(new Cluster(ClusterSpec.Id.from("c2"),
+                                 true,
                                  new ClusterResources( 8, 4, new NodeResources(1, 2, 3, 4)),
                                  new ClusterResources(14, 7, new NodeResources(3, 6, 21, 24)),
                                  Optional.of(new ClusterResources(20, 10, new NodeResources(0.5, 4, 14, 16))),
@@ -49,6 +51,7 @@ public class ApplicationSerializerTest {
             assertNotSame(originalCluster, serializedCluster);
             assertEquals(originalCluster, serializedCluster);
             assertEquals(originalCluster.id(), serializedCluster.id());
+            assertEquals(originalCluster.exclusive(), serializedCluster.exclusive());
             assertEquals(originalCluster.minResources(), serializedCluster.minResources());
             assertEquals(originalCluster.maxResources(), serializedCluster.maxResources());
             assertEquals(originalCluster.suggestedResources(), serializedCluster.suggestedResources());
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/DockerProvisioningTest.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/DockerProvisioningTest.java
index e4d464840ea..3c1cace3dac 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/DockerProvisioningTest.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/DockerProvisioningTest.java
@@ -39,8 +39,8 @@ import static org.junit.Assert.fail;
  */
 public class DockerProvisioningTest {
 
-    private static final NodeResources dockerFlavor = new NodeResources(1, 4, 100, 1,
-                                                                        NodeResources.DiskSpeed.fast, NodeResources.StorageType.local);
+    private static final NodeResources dockerResources = new NodeResources(1, 4, 100, 1,
+                                                                           NodeResources.DiskSpeed.fast, NodeResources.StorageType.local);
 
     @Test
     public void docker_application_deployment() {
@@ -48,28 +48,28 @@ public class DockerProvisioningTest {
         ApplicationId application1 = tester.makeApplicationId();
 
         for (int i = 1; i < 10; i++)
-            tester.makeReadyVirtualDockerNodes(1, dockerFlavor, "dockerHost" + i);
+            tester.makeReadyVirtualDockerNodes(1, dockerResources, "dockerHost" + i);
 
         Version wantedVespaVersion = Version.fromString("6.39");
         int nodeCount = 7;
         List<HostSpec> hosts = tester.prepare(application1,
                                               ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("myContent")).vespaVersion(wantedVespaVersion).build(),
-                                              nodeCount, 1, dockerFlavor);
+                                              nodeCount, 1, dockerResources);
         tester.activate(application1, new HashSet<>(hosts));
 
         NodeList nodes = tester.getNodes(application1, Node.State.active);
         assertEquals(nodeCount, nodes.size());
-        assertEquals(dockerFlavor, nodes.asList().get(0).flavor().resources());
+        assertEquals(dockerResources, nodes.asList().get(0).flavor().resources());
 
         // Upgrade Vespa version on nodes
         Version upgradedWantedVespaVersion = Version.fromString("6.40");
         List<HostSpec> upgradedHosts = tester.prepare(application1,
                                                       ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("myContent")).vespaVersion(upgradedWantedVespaVersion).build(),
-                                                      nodeCount, 1, dockerFlavor);
+                                                      nodeCount, 1, dockerResources);
         tester.activate(application1, new HashSet<>(upgradedHosts));
         NodeList upgradedNodes = tester.getNodes(application1, Node.State.active);
         assertEquals(nodeCount, upgradedNodes.size());
-        assertEquals(dockerFlavor, upgradedNodes.asList().get(0).flavor().resources());
+        assertEquals(dockerResources, upgradedNodes.asList().get(0).flavor().resources());
         assertEquals(hosts, upgradedHosts);
     }
 
@@ -80,14 +80,14 @@ public class DockerProvisioningTest {
         ApplicationId zoneApplication = tester.makeApplicationId();
         List<Node> parents = tester.makeReadyNodes(10, new NodeResources(2, 4, 20, 2), NodeType.host, 1);
         for (Node parent : parents)
-            tester.makeReadyVirtualDockerNodes(1, dockerFlavor, parent.hostname());
+            tester.makeReadyVirtualDockerNodes(1, dockerResources, parent.hostname());
 
         ApplicationId application1 = tester.makeApplicationId();
         Version wantedVespaVersion = Version.fromString("6.39");
         int nodeCount = 7;
         List<HostSpec> nodes = tester.prepare(application1,
-                ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("myContent")).vespaVersion(wantedVespaVersion).build(),
-                nodeCount, 1, dockerFlavor);
+                                              ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("myContent")).vespaVersion(wantedVespaVersion).build(),
+                                              nodeCount, 1, dockerResources);
         try {
             tester.activate(application1, new HashSet<>(nodes));
             fail("Expected the allocation to fail due to parent hosts not being active yet");
@@ -101,8 +101,8 @@ public class DockerProvisioningTest {
 
         // Try allocating tenants again
         nodes = tester.prepare(application1,
-                ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("myContent")).vespaVersion(wantedVespaVersion).build(),
-                nodeCount, 1, dockerFlavor);
+                               ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("myContent")).vespaVersion(wantedVespaVersion).build(),
+                               nodeCount, 1, dockerResources);
         tester.activate(application1, new HashSet<>(nodes));
 
         NodeList activeNodes = tester.getNodes(application1, Node.State.active);
@@ -153,13 +153,13 @@ public class DockerProvisioningTest {
     public void docker_application_deployment_with_exclusive_app_first() {
         ProvisioningTester tester = new ProvisioningTester.Builder().zone(new Zone(Environment.prod, RegionName.from("us-east"))).build();
         for (int i = 1; i <= 4; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host1");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host1");
         for (int i = 5; i <= 8; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host2");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host2");
         for (int i = 9; i <= 12; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host3");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host3");
         for (int i = 13; i <= 16; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host4");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host4");
 
         ApplicationId application1 = tester.makeApplicationId();
         prepareAndActivate(application1, 2, true, tester);
@@ -176,13 +176,13 @@ public class DockerProvisioningTest {
     public void docker_application_deployment_with_exclusive_app_last() {
         ProvisioningTester tester = new ProvisioningTester.Builder().zone(new Zone(Environment.prod, RegionName.from("us-east"))).build();
         for (int i = 1; i <= 4; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host1");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host1");
         for (int i = 5; i <= 8; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host2");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host2");
         for (int i = 9; i <= 12; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host3");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host3");
         for (int i = 13; i <= 16; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host4");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host4");
 
         ApplicationId application1 = tester.makeApplicationId();
         prepareAndActivate(application1, 2, false, tester);
@@ -199,13 +199,13 @@ public class DockerProvisioningTest {
     public void docker_application_deployment_change_to_exclusive_and_back() {
         ProvisioningTester tester = new ProvisioningTester.Builder().zone(new Zone(Environment.prod, RegionName.from("us-east"))).build();
         for (int i = 1; i <= 4; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host1");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host1");
         for (int i = 5; i <= 8; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host2");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host2");
         for (int i = 9; i <= 12; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host3");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host3");
         for (int i = 13; i <= 16; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host4");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host4");
 
         ApplicationId application1 = tester.makeApplicationId();
         prepareAndActivate(application1, 2, false, tester);
@@ -228,13 +228,13 @@ public class DockerProvisioningTest {
     public void docker_application_deployment_with_exclusive_app_causing_allocation_failure() {
         ProvisioningTester tester = new ProvisioningTester.Builder().zone(new Zone(Environment.prod, RegionName.from("us-east"))).build();
         for (int i = 1; i <= 4; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host1");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host1");
         for (int i = 5; i <= 8; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host2");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host2");
         for (int i = 9; i <= 12; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host3");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host3");
         for (int i = 13; i <= 16; i++)
-            tester.makeReadyVirtualDockerNode(i, dockerFlavor, "host4");
+            tester.makeReadyVirtualDockerNode(i, dockerResources, "host4");
 
         ApplicationId application1 = tester.makeApplicationId();
         prepareAndActivate(application1, 2, true, tester);
@@ -266,11 +266,11 @@ public class DockerProvisioningTest {
     public void get_specified_flavor_not_default_flavor_for_docker() {
         ProvisioningTester tester = new ProvisioningTester.Builder().zone(new Zone(Environment.test, RegionName.from("corp-us-east-1"))).build();
         ApplicationId application1 = tester.makeApplicationId();
-        tester.makeReadyVirtualDockerNodes(1, dockerFlavor, "dockerHost");
+        tester.makeReadyVirtualDockerNodes(1, dockerResources, "dockerHost");
 
         List<HostSpec> hosts = tester.prepare(application1,
                                               ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("myContent")).vespaVersion("6.42").build(),
-                                              1, 1, dockerFlavor);
+                                              1, 1, dockerResources);
         tester.activate(application1, new HashSet<>(hosts));
 
         NodeList nodes = tester.getNodes(application1, Node.State.active);
@@ -284,13 +284,13 @@ public class DockerProvisioningTest {
             ProvisioningTester tester = new ProvisioningTester.Builder()
                                                 .zone(new Zone(Environment.prod, RegionName.from("us-east-1"))).build();
             ApplicationId application1 = tester.makeApplicationId("app1");
-            tester.makeReadyVirtualDockerNodes(1, dockerFlavor, "dockerHost1");
-            tester.makeReadyVirtualDockerNodes(1, dockerFlavor, "dockerHost2");
+            tester.makeReadyVirtualDockerNodes(1, dockerResources, "dockerHost1");
+            tester.makeReadyVirtualDockerNodes(1, dockerResources, "dockerHost2");
 
-            List<HostSpec> hosts = tester.prepare(application1,
-                                                  ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("myContent")).vespaVersion("6.42").build(),
-                                                  2, 1,
-                                                  dockerFlavor.with(NodeResources.StorageType.remote));
+            tester.prepare(application1,
+                           ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("myContent")).vespaVersion("6.42").build(),
+                           2, 1,
+                           dockerResources.with(NodeResources.StorageType.remote));
         }
         catch (OutOfCapacityException e) {
             assertEquals("Could not satisfy request for 2 nodes with " +
@@ -308,7 +308,7 @@ public class DockerProvisioningTest {
     private void prepareAndActivate(ApplicationId application, int nodeCount, boolean exclusive, ProvisioningTester tester) {
         Set<HostSpec> hosts = new HashSet<>(tester.prepare(application,
                                             ClusterSpec.request(ClusterSpec.Type.container, ClusterSpec.Id.from("myContainer")).vespaVersion("6.39").exclusive(exclusive).build(),
-                                            Capacity.from(new ClusterResources(nodeCount, 1, dockerFlavor), false, true)));
+                                            Capacity.from(new ClusterResources(nodeCount, 1, dockerResources), false, true)));
         tester.activate(application, hosts);
     }
 
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/DynamicDockerProvisionTest.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/DynamicDockerProvisionTest.java
index 7ef780b8b7f..087f8f83f0c 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/DynamicDockerProvisionTest.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/DynamicDockerProvisionTest.java
@@ -47,6 +47,7 @@ import static org.mockito.Mockito.verify;
 
 /**
  * @author freva
+ * @author bratseth
  */
 public class DynamicDockerProvisionTest {
 
@@ -159,14 +160,14 @@ public class DynamicDockerProvisionTest {
     }
 
     @Test
-    public void test_capacity_is_in_advertised_amounts_on_aws() {
+    public void test_capacity_is_in_advertised_amounts() {
         int memoryTax = 3;
         List<Flavor> flavors = List.of(new Flavor("2x",
                                                   new NodeResources(2, 17, 200, 10, fast, remote)));
 
         ProvisioningTester tester = new ProvisioningTester.Builder().zone(zone)
                                                                     .flavors(flavors)
-                                                                    .hostProvisioner(new MockHostProvisioner(flavors, memoryTax, 0))
+                                                                    .hostProvisioner(new MockHostProvisioner(flavors, memoryTax))
                                                                     .nameResolver(nameResolver)
                                                                     .resourcesCalculator(new MockResourcesCalculator(memoryTax, 0))
                                                                     .build();
@@ -204,7 +205,7 @@ public class DynamicDockerProvisionTest {
     }
 
     @Test
-    public void test_changing_limits_on_aws() {
+    public void test_changing_limits() {
         int memoryTax = 3;
         List<Flavor> flavors = List.of(new Flavor("1x", new NodeResources(1, 10 - memoryTax, 100, 0.1, fast, remote)),
                                        new Flavor("2x", new NodeResources(2, 20 - memoryTax, 200, 0.1, fast, remote)),
@@ -212,7 +213,7 @@ public class DynamicDockerProvisionTest {
 
         ProvisioningTester tester = new ProvisioningTester.Builder().zone(zone)
                                                                     .flavors(flavors)
-                                                                    .hostProvisioner(new MockHostProvisioner(flavors, memoryTax, 0))
+                                                                    .hostProvisioner(new MockHostProvisioner(flavors, memoryTax))
                                                                     .nameResolver(nameResolver)
                                                                     .resourcesCalculator(new MockResourcesCalculator(memoryTax, 0))
                                                                     .build();
@@ -278,7 +279,7 @@ public class DynamicDockerProvisionTest {
     }
 
     @Test
-    public void test_changing_storage_type_on_aws() {
+    public void test_changing_storage_type() {
         int memoryTax = 3;
         List<Flavor> flavors = List.of(new Flavor("2x",  new NodeResources(2, 20 - memoryTax, 200, 0.1, fast, remote)),
                                        new Flavor("2xl", new NodeResources(2, 20 - memoryTax, 200, 0.1, fast, local)),
@@ -287,7 +288,7 @@ public class DynamicDockerProvisionTest {
 
         ProvisioningTester tester = new ProvisioningTester.Builder().zone(zone)
                                                                     .flavors(flavors)
-                                                                    .hostProvisioner(new MockHostProvisioner(flavors, memoryTax, 0))
+                                                                    .hostProvisioner(new MockHostProvisioner(flavors, memoryTax))
                                                                     .nameResolver(nameResolver)
                                                                     .resourcesCalculator(new MockResourcesCalculator(memoryTax, 0))
                                                                     .build();
@@ -314,14 +315,15 @@ public class DynamicDockerProvisionTest {
     public void test_any_disk_prefers_remote() {
         int memoryTax = 3;
         int localDiskTax = 55;
-        List<Flavor> flavors = List.of(new Flavor("2x",  new NodeResources(2, 20 - memoryTax, 200 - localDiskTax, 0.1, fast, local)),
-                                       new Flavor("4x",  new NodeResources(4, 40 - memoryTax, 400 - localDiskTax, 0.1, fast, local)),
+        // Disk tax is not included in flavor resources but memory tax is
+        List<Flavor> flavors = List.of(new Flavor("2x",  new NodeResources(2, 20 - memoryTax, 200, 0.1, fast, local)),
+                                       new Flavor("4x",  new NodeResources(4, 40 - memoryTax, 400, 0.1, fast, local)),
                                        new Flavor("2xl", new NodeResources(2, 20 - memoryTax, 200, 0.1, fast, remote)),
                                        new Flavor("4xl", new NodeResources(4, 40 - memoryTax, 400, 0.1, fast, remote)));
 
         ProvisioningTester tester = new ProvisioningTester.Builder().zone(zone)
                                                                     .flavors(flavors)
-                                                                    .hostProvisioner(new MockHostProvisioner(flavors, memoryTax, localDiskTax))
+                                                                    .hostProvisioner(new MockHostProvisioner(flavors, memoryTax))
                                                                     .nameResolver(nameResolver)
                                                                     .resourcesCalculator(new MockResourcesCalculator(memoryTax, localDiskTax))
                                                                     .build();
@@ -385,8 +387,19 @@ public class DynamicDockerProvisionTest {
         public NodeResources advertisedResourcesOf(Flavor flavor) {
             NodeResources resources = flavor.resources();
             if ( ! flavor.isConfigured()) return resources;
+            return resources.withMemoryGb(resources.memoryGb() + memoryTaxGb);
+        }
+
+        @Override
+        public NodeResources requestToReal(NodeResources resources) {
+            return resources.withMemoryGb(resources.memoryGb() - memoryTaxGb)
+                            .withDiskGb(resources.diskGb() - ( resources.storageType() == local ? localDiskTax : 0) );
+        }
+
+        @Override
+        public NodeResources realToRequest(NodeResources resources) {
             return resources.withMemoryGb(resources.memoryGb() + memoryTaxGb)
-                            .withDiskGb(resources.diskGb() + ( resources.storageType() == local ? localDiskTax : 0));
+                            .withDiskGb(resources.diskGb() + ( resources.storageType() == local ? localDiskTax : 0) );
         }
 
     }
@@ -395,12 +408,10 @@ public class DynamicDockerProvisionTest {
 
         private final List<Flavor> hostFlavors;
         private final int memoryTaxGb;
-        private final int localDiskTaxGb;
 
-        public MockHostProvisioner(List<Flavor> hostFlavors, int memoryTaxGb, int localDiskTaxGb) {
+        public MockHostProvisioner(List<Flavor> hostFlavors, int memoryTaxGb) {
             this.hostFlavors = List.copyOf(hostFlavors);
             this.memoryTaxGb = memoryTaxGb;
-            this.localDiskTaxGb = localDiskTaxGb;
         }
 
         @Override
@@ -414,8 +425,7 @@ public class DynamicDockerProvisionTest {
         }
 
         private boolean compatible(Flavor hostFlavor, NodeResources resources) {
-            NodeResources resourcesToVerify = resources.withMemoryGb(resources.memoryGb() - memoryTaxGb)
-                                                       .withDiskGb(resources.diskGb() - ( resources.storageType() == local ? localDiskTaxGb : 0));
+            NodeResources resourcesToVerify = resources.withMemoryGb(resources.memoryGb() - memoryTaxGb);
 
             if (hostFlavor.resources().storageType() == NodeResources.StorageType.remote
                 && hostFlavor.resources().diskGb() >= resources.diskGb())
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/ProvisioningTester.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/ProvisioningTester.java
index 326af2fc60a..92e64e752a7 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/ProvisioningTester.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/provisioning/ProvisioningTester.java
@@ -556,7 +556,8 @@ public class ProvisioningTester {
         }
 
         public Builder resourcesCalculator(HostResourcesCalculator resourcesCalculator) {
-            this.resourcesCalculator = resourcesCalculator;
+            if (resourcesCalculator != null)
+                this.resourcesCalculator = resourcesCalculator;
             return this;
         }