Don’t oversubscribe the CPU with tasks

This dramatically increases multithreaded performance:

Before:
https://browser.geekbench.com/v6/cpu/3115104

After:
https://browser.geekbench.com/v6/cpu/3115190

Author: jkmassel

Sources/libhostmgr/Model/Configuration.swift

@@ -52,9 +52,13 @@ public struct Configuration: Codable {
     public var allowAWSAcceleratedTransfer: Bool! = Defaults.defaultAWSAcceleratedTransferAllowed
     public var awsConfigurationMethod: AWSConfigurationType! = Defaults.defaultAWSConfigurationMethod
 
-    /// VM Memory Settings
-    public static let hostReservedRAM: UInt64 = 1024 * 1024 * 4096 // Leave 4GB for the VM host
-    public var useSharedMemoryCapacity: Bool = false
+    // MARK: VM Resource Settings
+
+    /// Should this node run more than one concurrent VM?
+    public let isSharedNode: Bool = false
+
+    /// How much RAM should be reserved for the host (and not allocated to VMs)
+    public let hostReservedRAM: UInt64 = 1024 * 1024 * 2048 // Leave 2GB for the VM host
 
     enum CodingKeys: String, CodingKey {
         case version

Sources/libhostmgr/VM/VMConfiguration.swift

@@ -41,16 +41,25 @@ struct VMConfiguration {
         return virtualMachineConfiguration
     }
 
+    func calculateCPUCount(shared: Bool) -> Int {
+        if shared {
+            return (ProcessInfo.processInfo.physicalProcessorCount - 1).quotientAndRemainder(dividingBy: 2).quotient
+        }
+
+        return ProcessInfo.processInfo.physicalProcessorCount
+    }
+
     var cpuCount: Int {
-        VZVirtualMachineConfiguration.maximumAllowedCPUCount - 1
+        calculateCPUCount(shared: Configuration.shared.isSharedNode)
     }
 
     func calculateMemorySize(
         min _min: UInt64 = VZVirtualMachineConfiguration.minimumAllowedMemorySize,
         max _max: UInt64 = VZVirtualMachineConfiguration.maximumAllowedMemorySize,
+        hostReserved: UInt64 = Configuration.shared.hostReservedRAM,
         shared: Bool
     ) -> UInt64 {
-        let vmReservedSize = _max - Configuration.hostReservedRAM
+        let vmReservedSize = _max - hostReserved
 
         if shared {
             return min(max(_min, vmReservedSize.quotientAndRemainder(dividingBy: 2).quotient), _max)
@@ -60,7 +69,7 @@ struct VMConfiguration {
     }
 
     var memorySize: UInt64 {
-        calculateMemorySize(shared: Configuration.shared.useSharedMemoryCapacity)
+        calculateMemorySize(shared: Configuration.shared.isSharedNode)
     }
 
     var graphicsConfiguration: [VZMacGraphicsDeviceConfiguration] {

Tests/libhostmgrTests/VM/VMConfigurationTests.swift

@@ -2,70 +2,96 @@ import XCTest
 @testable import libhostmgr
 
 final class VMConfigurationTests: XCTestCase {
+    let min: UInt64 = 4_194_304
+    let hostReservedRAM: UInt64 = 1024 * 1024 * 4096
 
     func testThatMemorySizeCalculationsAreValidForUnshared8GBCapacity() throws {
-        let min: UInt64 = 4_194_304
         let max: UInt64 = 8_589_934_592
         let configuration = try VMConfiguration(
             diskImagePath: URL(fileURLWithPath: "/dev/null"),
             macAddress: .randomLocallyAdministered()
         )
 
-        XCTAssertEqual(configuration.calculateMemorySize(min: min, max: max, shared: false), 4_294_967_296)
+        XCTAssertEqual(configuration.calculateMemorySize(
+            min: min,
+            max: max,
+            hostReserved: hostReservedRAM,
+            shared: false
+        ), 4_294_967_296)
     }
 
     func testThatMemorySizeCalculationsAreValidForShared8GBCapacity() throws {
-        let min: UInt64 = 4_194_304
         let max: UInt64 = 8_589_934_592
         let configuration = try VMConfiguration(
             diskImagePath: URL(fileURLWithPath: "/dev/null"),
             macAddress: .randomLocallyAdministered()
         )
 
-        XCTAssertEqual(configuration.calculateMemorySize(min: min, max: max, shared: true), 2_147_483_648)
+        XCTAssertEqual(configuration.calculateMemorySize(
+            min: min,
+            max: max,
+            hostReserved: hostReservedRAM,
+            shared: true
+        ), 2_147_483_648)
     }
 
     func testThatMemorySizeCalculationsAreValidForUnshared16GBCapacity() throws {
-        let min: UInt64 = 4_194_304
         let max: UInt64 = 17_179_869_184
         let configuration = try VMConfiguration(
             diskImagePath: URL(fileURLWithPath: "/dev/null"),
             macAddress: .randomLocallyAdministered()
         )
 
-        XCTAssertEqual(configuration.calculateMemorySize(min: min, max: max, shared: false), 12_884_901_888)
+        XCTAssertEqual(configuration.calculateMemorySize(
+            min: min,
+            max: max,
+            hostReserved: hostReservedRAM,
+            shared: false
+        ), 12_884_901_888)
     }
 
     func testThatMemorySizeCalculationsAreValidForShared16GBCapacity() throws {
-        let min: UInt64 = 4_194_304
         let max: UInt64 = 17_179_869_184
         let configuration = try VMConfiguration(
             diskImagePath: URL(fileURLWithPath: "/dev/null"),
             macAddress: .randomLocallyAdministered()
         )
 
-        XCTAssertEqual(configuration.calculateMemorySize(min: min, max: max, shared: true), 6_442_450_944)
+        XCTAssertEqual(configuration.calculateMemorySize(
+            min: min,
+            max: max,
+            hostReserved: hostReservedRAM,
+            shared: true
+        ), 6_442_450_944)
     }
 
     func testThatMemorySizeCalculationsAreValidForUnshared32GBCapacity() throws {
-        let min: UInt64 = 4_194_304
         let max: UInt64 = 34_359_738_368
         let configuration = try VMConfiguration(
             diskImagePath: URL(fileURLWithPath: "/dev/null"),
             macAddress: .randomLocallyAdministered()
         )
 
-        XCTAssertEqual(configuration.calculateMemorySize(min: min, max: max, shared: false), 30_064_771_072)
+        XCTAssertEqual(configuration.calculateMemorySize(
+            min: min,
+            max: max,
+            hostReserved: hostReservedRAM,
+            shared: false
+        ), 30_064_771_072)
     }
 
     func testThatMemorySizeCalculationsAreValidForShared32GBCapacity() throws {
-        let min: UInt64 = 4_194_304
         let max: UInt64 = 34_359_738_368
         let configuration = try VMConfiguration(
             diskImagePath: URL(fileURLWithPath: "/dev/null"),
             macAddress: .randomLocallyAdministered()
         )
 
-        XCTAssertEqual(configuration.calculateMemorySize(min: min, max: max, shared: true), 15_032_385_536)
+        XCTAssertEqual(configuration.calculateMemorySize(
+            min: min,
+            max: max,
+            hostReserved: hostReservedRAM,
+            shared: true
+        ), 15_032_385_536)
     }
 }