service-capacity-modeling 0.3.68__py3-none-any.whl → 0.3.70__py3-none-any.whl

service_capacity_modeling/models/common.py

@@ -69,6 +69,43 @@ def _sqrt_staffed_cores(rps: float, latency_s: float, qos: float) -> int:
     return math.ceil((rps * latency_s) + qos * math.sqrt(rps * latency_s))
 
 
+def get_effective_disk_per_node_gib(
+    instance: Instance,
+    drive: Drive,
+    disk_buffer_ratio: float,
+    max_local_data_per_node_gib: float = float("inf"),
+    max_attached_data_per_node_gib: float = float("inf"),
+) -> float:
+    """Calculate usable disk for an instance while respecting per-node data limits
+    and desired disk buffer ratio
+
+    Prevents overloading nodes with too much data, which causes slow bootstrapping and
+    recovery times
+
+    Args:
+        instance: The compute instance configuration
+        drive: The drive configuration for the instance
+        disk_buffer_ratio: Buffer ratio for operational headroom
+        max_local_data_per_node_gib: Maximum data per node for local drives
+        max_attached_data_per_node_gib: Maximum data per node for attached drives
+
+    Returns:
+        float: Maximum usable disk capacity per node in GiB
+    """
+    # TODO: @homatthew / @vrayini: Incorporate disk headroom for attached / local drives
+    if instance.drive is None:
+        if max_attached_data_per_node_gib == float("inf"):
+            return drive.max_size_gib
+
+        attached_disk_limit_gib = max_attached_data_per_node_gib * disk_buffer_ratio
+        # Attached disks are provisioned in 100GB limits
+        rounded_size = utils.next_n(attached_disk_limit_gib, n=100)
+        return min(rounded_size, drive.max_size_gib)
+
+    local_disk_limit_gib = max_local_data_per_node_gib * disk_buffer_ratio
+    return min(local_disk_limit_gib, instance.drive.size_gib)
+
+
 def sqrt_staffed_cores(desires: CapacityDesires) -> int:
     """Computes cores given a sqrt staffing model
 
@@ -357,11 +394,6 @@ def compute_stateful_zone(  # pylint: disable=too-many-positional-arguments
     # (per_node_size_gib, node_count) -> (read_ios, write_ios)
     required_disk_ios: Callable[[float, int], Tuple[float, float]] = lambda size_gib,
     count: (0, 0),
-    required_disk_space: Callable[[float], float] = lambda size_gib: size_gib,
-    # The maximum amount of state we can hold per node in the database
-    # typically you don't want stateful systems going much higher than a
-    # few TiB so that recovery functions properly
-    max_local_disk_gib: float = 2048,
     # Some stateful clusters have sidecars that take memory
     reserve_memory: Callable[[float], float] = lambda x: 0,
     # How much write buffer we get per instance (usually a percentage of
@@ -373,14 +405,7 @@ def compute_stateful_zone(  # pylint: disable=too-many-positional-arguments
     min_count: int = 0,
     adjusted_disk_io_needed: float = 0.0,
     read_write_ratio: float = 0.0,
-    # Max attached EBS volume size per node. Higher value here could allow
-    # for a lower instance count (allows more vertical scaling vs forcing horizontal)
-    max_attached_disk_gib: Optional[float] = None,
 ) -> ZoneClusterCapacity:
-    # Datastores often require disk headroom for e.g. compaction and such
-    if instance.drive is not None:
-        needed_disk_gib = math.ceil(required_disk_space(needed_disk_gib))
-
     # How many instances do we need for the CPU
     count = math.ceil(needed_cores / instance.cpu)
 
@@ -404,12 +429,8 @@ def compute_stateful_zone(  # pylint: disable=too-many-positional-arguments
     count = max(count, math.ceil(needed_network_mbps / instance.net_mbps))
 
     # How many instances do we need for the disk
-    if (
-        instance.drive is not None
-        and instance.drive.size_gib > 0
-        and max_local_disk_gib > 0
-    ):
-        disk_per_node = min(max_local_disk_gib, instance.drive.size_gib)
+    if instance.drive is not None and instance.drive.size_gib > 0:
+        disk_per_node = instance.drive.size_gib
         count = max(count, math.ceil(needed_disk_gib / disk_per_node))
         if adjusted_disk_io_needed != 0.0:
             instance_read_iops = (
@@ -441,13 +462,13 @@ def compute_stateful_zone(  # pylint: disable=too-many-positional-arguments
     cost = count * instance.annual_cost
 
     attached_drives = []
-    if instance.drive is None and required_disk_space(needed_disk_gib) > 0:
+    if instance.drive is None and needed_disk_gib > 0:
         # If we don't have disks attach the cloud drive with enough
         # space and IO for the requirement
 
         # Note that cloud drivers are provisioned _per node_ and must be chosen for
         # the max of space and IOS.
-        space_gib = max(1, math.ceil(required_disk_space(needed_disk_gib) / count))
+        space_gib = max(1, math.ceil(needed_disk_gib / count))
         read_io, write_io = required_disk_ios(space_gib, count)
         read_io, write_io = (
             utils.next_n(read_io, n=200),
@@ -463,9 +484,6 @@ def compute_stateful_zone(  # pylint: disable=too-many-positional-arguments
         # 1/3 the maximum volume size in one node (preferring more nodes
         # with smaller volumes)
         max_size = drive.max_size_gib / 3
-        if max_attached_disk_gib is not None:
-            max_size = max_attached_disk_gib
-
         if ebs_gib > max_size > 0:
             ratio = ebs_gib / max_size
             count = max(cluster_size(math.ceil(count * ratio)), min_count)

service_capacity_modeling/models/org/netflix/cassandra.py

@@ -21,6 +21,7 @@ from service_capacity_modeling.interface import certain_float
 from service_capacity_modeling.interface import certain_int
 from service_capacity_modeling.interface import Clusters
 from service_capacity_modeling.interface import Consistency
+from service_capacity_modeling.interface import CurrentClusterCapacity
 from service_capacity_modeling.interface import DataShape
 from service_capacity_modeling.interface import Drive
 from service_capacity_modeling.interface import FixedInterval
@@ -35,12 +36,15 @@ from service_capacity_modeling.models import CapacityModel
 from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
 from service_capacity_modeling.models.common import derived_buffer_for_component
+from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
 from service_capacity_modeling.models.common import network_services
 from service_capacity_modeling.models.common import normalize_cores
 from service_capacity_modeling.models.common import simple_network_mbps
 from service_capacity_modeling.models.common import sqrt_staffed_cores
 from service_capacity_modeling.models.common import working_set_from_drive_and_slo
 from service_capacity_modeling.models.common import zonal_requirements_from_current
+from service_capacity_modeling.models.utils import is_power_of_2
+from service_capacity_modeling.models.utils import next_doubling
 from service_capacity_modeling.models.utils import next_power_of_2
 from service_capacity_modeling.stats import dist_for_interval
 
@@ -106,6 +110,53 @@ def _get_disk_from_desires(desires, copies_per_region):
     )
 
 
+def _get_min_count(
+    tier: int,
+    required_cluster_size: Optional[int],
+    needed_disk_gib: float,
+    disk_per_node_gib: float,
+    cluster_size_lambda: Callable[[int], int],
+):
+    """
+    Compute the minimum number of nodes required for a zone.
+
+    This function is used to prevent the planner from allocating clusters that
+    would exceed the max data per node or under the required cluster size for
+    a tier or existing cluster
+    """
+
+    # Cassandra clusters should aim to be at least 2 nodes per zone to start
+    # out with for tier 0 or tier 1. This gives us more room to "up-color"]
+    # clusters.
+    min_nodes_for_tier = 2 if tier in CRITICAL_TIERS else 0
+
+    # Prevent allocating clusters that exceed the max data per node.
+    min_nodes_for_disk = math.ceil(needed_disk_gib / disk_per_node_gib)
+
+    # Take the max of the following in order to avoid:
+    # (1) if `required_cluster_size` < `min_nodes_for_disk`, don't let the planner
+    #     pick a shape that would exceed the max data per node
+    #
+    #     For example, if we need 4TiB of disk, and the max data per node is 1TiB,
+    #     Regardless of the `required_cluster_size`, we cannot allocate less than 4
+    #     nodes because that would exceed the max data per node.
+    #
+    # (2) if `required_cluster_size` > `min_nodes_for_disk`, don't let the
+    #     node density requirement affect the min count because the required
+    #     cluster size already meets the node density requirement.
+    #
+    #     For example, if we need 4TiB of disk, and the max data per node is 1TiB,
+    #     and the upstream requires >= 8 nodes, we can allocate 8 nodes because
+    #     each node would only have 500GB of data.
+    min_count = max(
+        min_nodes_for_tier,
+        required_cluster_size or 0,
+        min_nodes_for_disk,
+    )
+    # Ensure that the min count is an increment of the cluster size constraint (doubling)
+    return cluster_size_lambda(min_count)
+
+
 def _zonal_requirement_for_new_cluster(
     desires, instance, copies_per_region, zones_per_region
 ) -> CapacityRequirement:
@@ -149,15 +200,7 @@ def _estimate_cassandra_requirement(  # pylint: disable=too-many-positional-argu
     )
     memory_preserve = False
     reference_shape = desires.reference_shape
-    current_capacity = (
-        None
-        if desires.current_clusters is None
-        else (
-            desires.current_clusters.zonal[0]
-            if len(desires.current_clusters.zonal)
-            else desires.current_clusters.regional[0]
-        )
-    )
+    current_capacity = _get_current_capacity(desires)
 
     # If the cluster is already provisioned
     if current_capacity and desires.current_clusters is not None:
@@ -277,6 +320,26 @@ def _estimate_cassandra_requirement(  # pylint: disable=too-many-positional-argu
     )
 
 
+def _get_current_cluster_size(desires) -> int:
+    current_capacity = _get_current_capacity(desires)
+    if current_capacity is None:
+        return 0
+    return math.ceil(current_capacity.cluster_instance_count.mid)
+
+
+def _get_current_capacity(desires) -> Optional[CurrentClusterCapacity]:
+    current_capacity = (
+        None
+        if desires.current_clusters is None
+        else (
+            desires.current_clusters.zonal[0]
+            if len(desires.current_clusters.zonal)
+            else desires.current_clusters.regional[0]
+        )
+    )
+    return current_capacity
+
+
 def _upsert_params(cluster, params):
     if cluster.cluster_params:
         cluster.cluster_params.update(params)
@@ -284,6 +347,18 @@ def _upsert_params(cluster, params):
         cluster.cluster_params = params
 
 
+def _get_cluster_size_lambda(
+    current_cluster_size: int,
+    required_cluster_size: Optional[int],
+) -> Callable[[int], int]:
+    if required_cluster_size:
+        return lambda x: next_doubling(x, base=required_cluster_size)
+    elif current_cluster_size and not is_power_of_2(current_cluster_size):
+        return lambda x: next_doubling(x, base=current_cluster_size)
+    else:  # New provisionings
+        return next_power_of_2
+
+
 # pylint: disable=too-many-locals
 # pylint: disable=too-many-return-statements
 # flake8: noqa: C901
@@ -298,7 +373,8 @@ def _estimate_cassandra_cluster_zonal(  # pylint: disable=too-many-positional-ar
     require_attached_disks: bool = False,
     required_cluster_size: Optional[int] = None,
     max_rps_to_disk: int = 500,
-    max_local_disk_gib: int = 5120,
+    max_local_data_per_node_gib: int = 1280,
+    max_attached_data_per_node_gib: int = 2048,
     max_regional_size: int = 192,
     max_write_buffer_percent: float = 0.25,
     max_table_buffer_percent: float = 0.11,
@@ -361,10 +437,31 @@ def _estimate_cassandra_cluster_zonal(  # pylint: disable=too-many-positional-ar
         copies_per_region=copies_per_region,
     )
 
-    # Cassandra clusters should aim to be at least 2 nodes per zone to start
-    # out with for tier 0 or tier 1. This gives us more room to "up-color"]
-    # clusters.
-    min_count = 2 if desires.service_tier in CRITICAL_TIERS else 0
+    # Adjust the min count to adjust to prevent too much data on a single
+    needed_disk_gib = int(requirement.disk_gib.mid)
+    disk_buffer_ratio = buffer_for_components(
+        buffers=desires.buffers, components=[BufferComponent.disk]
+    ).ratio
+    disk_per_node_gib = get_effective_disk_per_node_gib(
+        instance,
+        drive,
+        disk_buffer_ratio,
+        max_local_data_per_node_gib=max_local_data_per_node_gib,
+        max_attached_data_per_node_gib=max_attached_data_per_node_gib,
+    )
+
+    current_cluster_size = _get_current_cluster_size(desires)
+    cluster_size_lambda = _get_cluster_size_lambda(
+        current_cluster_size, required_cluster_size
+    )
+    min_count = _get_min_count(
+        tier=desires.service_tier,
+        required_cluster_size=required_cluster_size,
+        needed_disk_gib=needed_disk_gib,
+        disk_per_node_gib=disk_per_node_gib,
+        cluster_size_lambda=cluster_size_lambda,
+    )
+
     base_mem = _get_base_memory(desires)
 
     heap_fn = _cass_heap_for_write_buffer(
@@ -378,7 +475,7 @@ def _estimate_cassandra_cluster_zonal(  # pylint: disable=too-many-positional-ar
         instance=instance,
         drive=drive,
         needed_cores=int(requirement.cpu_cores.mid),
-        needed_disk_gib=int(requirement.disk_gib.mid),
+        needed_disk_gib=needed_disk_gib,
         needed_memory_gib=int(requirement.mem_gib.mid),
         needed_network_mbps=requirement.network_mbps.mid,
         # Take into account the reads per read
@@ -387,14 +484,9 @@ def _estimate_cassandra_cluster_zonal(  # pylint: disable=too-many-positional-ar
             _cass_io_per_read(size) * math.ceil(read_io_per_sec / count),
             write_io_per_sec / count,
         ),
-        # Disk buffer is already added while computing C* estimates
-        required_disk_space=lambda x: x,
-        # C* clusters cannot recover data from neighbors quickly so we
-        # want to avoid clusters with more than 1 TiB of local state
-        max_local_disk_gib=max_local_disk_gib,
         # C* clusters provision in powers of 2 because doubling
-        cluster_size=next_power_of_2,
-        min_count=max(min_count, required_cluster_size or 0),
+        cluster_size=cluster_size_lambda,
+        min_count=min_count,
         # TODO: Take reserve memory calculation into account during buffer calculation
         # C* heap usage takes away from OS page cache memory
         reserve_memory=lambda x: base_mem + heap_fn(x),
@@ -617,6 +709,11 @@ class NflxCassandraCapacityModel(CapacityModel):
         desires: CapacityDesires,
         extra_model_arguments: Dict[str, Any],
     ) -> Optional[CapacityPlan]:
+        # TODO: Standardize these extra model argument defaults in a single
+        # place. Many of them are defined here and as default values in the
+        # downstream method but only these ones are used which is confusing for
+        # readability
+
         # Use durabiliy and consistency to compute RF.
         copies_per_region = _target_rf(
             desires, extra_model_arguments.get("copies_per_region", None)
@@ -635,7 +732,11 @@ class NflxCassandraCapacityModel(CapacityModel):
 
         max_rps_to_disk: int = extra_model_arguments.get("max_rps_to_disk", 500)
         max_regional_size: int = extra_model_arguments.get("max_regional_size", 192)
-        max_local_disk_gib: int = extra_model_arguments.get("max_local_disk_gib", 5120)
+        max_local_data_per_node_gib: int = extra_model_arguments.get(
+            "max_local_data_per_node_gib",
+            extra_model_arguments.get("max_local_disk_gib", 1280),
+        )
+
         max_write_buffer_percent: float = min(
             0.5, extra_model_arguments.get("max_write_buffer_percent", 0.25)
         )
@@ -663,7 +764,7 @@ class NflxCassandraCapacityModel(CapacityModel):
             required_cluster_size=required_cluster_size,
             max_rps_to_disk=max_rps_to_disk,
             max_regional_size=max_regional_size,
-            max_local_disk_gib=max_local_disk_gib,
+            max_local_data_per_node_gib=max_local_data_per_node_gib,
             max_write_buffer_percent=max_write_buffer_percent,
             max_table_buffer_percent=max_table_buffer_percent,
         )
@@ -676,6 +777,26 @@ class NflxCassandraCapacityModel(CapacityModel):
     def extra_model_arguments_schema() -> Dict[str, Any]:
         return NflxCassandraArguments.model_json_schema()
 
+    @staticmethod
+    def default_buffers() -> Buffers:
+        return Buffers(
+            default=Buffer(ratio=1.5),
+            desired={
+                "compute": Buffer(ratio=1.5, components=[BufferComponent.compute]),
+                "storage": Buffer(ratio=4.0, components=[BufferComponent.storage]),
+                # Cassandra reserves headroom in both cpu and network for background
+                # work and tasks
+                "background": Buffer(
+                    ratio=2.0,
+                    components=[
+                        BufferComponent.cpu,
+                        BufferComponent.network,
+                        BACKGROUND_BUFFER,
+                    ],
+                ),
+            },
+        )
+
     @staticmethod
     def default_desires(user_desires, extra_model_arguments: Dict[str, Any]):
         acceptable_consistency = {
@@ -703,24 +824,7 @@ class NflxCassandraCapacityModel(CapacityModel):
 
         # By supplying these buffers we can deconstruct observed utilization into
         # load versus buffer.
-        buffers = Buffers(
-            default=Buffer(ratio=1.5),
-            desired={
-                "compute": Buffer(ratio=1.5, components=[BufferComponent.compute]),
-                "storage": Buffer(ratio=4.0, components=[BufferComponent.storage]),
-                # Cassandra reserves headroom in both cpu and network for background
-                # work and tasks
-                "background": Buffer(
-                    ratio=2.0,
-                    components=[
-                        BufferComponent.cpu,
-                        BufferComponent.network,
-                        BACKGROUND_BUFFER,
-                    ],
-                ),
-            },
-        )
-
+        buffers = NflxCassandraCapacityModel.default_buffers()
         if user_desires.query_pattern.access_pattern == AccessPattern.latency:
             return CapacityDesires(
                 query_pattern=QueryPattern(

service_capacity_modeling/models/org/netflix/crdb.py

@@ -10,6 +10,9 @@ from pydantic import Field
 
 from service_capacity_modeling.interface import AccessConsistency
 from service_capacity_modeling.interface import AccessPattern
+from service_capacity_modeling.interface import Buffer
+from service_capacity_modeling.interface import BufferComponent
+from service_capacity_modeling.interface import Buffers
 from service_capacity_modeling.interface import CapacityDesires
 from service_capacity_modeling.interface import CapacityPlan
 from service_capacity_modeling.interface import CapacityRequirement
@@ -27,7 +30,9 @@ from service_capacity_modeling.interface import QueryPattern
 from service_capacity_modeling.interface import RegionContext
 from service_capacity_modeling.interface import Requirements
 from service_capacity_modeling.models import CapacityModel
+from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
+from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
 from service_capacity_modeling.models.common import normalize_cores
 from service_capacity_modeling.models.common import simple_network_mbps
 from service_capacity_modeling.models.common import sqrt_staffed_cores
@@ -137,7 +142,7 @@ def _estimate_cockroachdb_cluster_zonal(  # noqa=E501 pylint: disable=too-many-p
     desires: CapacityDesires,
     zones_per_region: int = 3,
     copies_per_region: int = 3,
-    max_local_disk_gib: int = 2048,
+    max_local_data_per_node_gib: int = 2048,
     max_regional_size: int = 288,
     max_rps_to_disk: int = 500,
     min_vcpu_per_instance: int = 4,
@@ -184,11 +189,23 @@ def _estimate_cockroachdb_cluster_zonal(  # noqa=E501 pylint: disable=too-many-p
         + desires.data_shape.reserved_instance_system_mem_gib
     )
 
+    disk_buffer_ratio = buffer_for_components(
+        buffers=desires.buffers, components=[BufferComponent.disk]
+    ).ratio
+    max_data_per_node_gib = get_effective_disk_per_node_gib(
+        instance,
+        drive,
+        disk_buffer_ratio,
+        max_local_data_per_node_gib=max_local_data_per_node_gib,
+    )
+    needed_disk_gib = requirement.disk_gib.mid * disk_buffer_ratio
+    min_count = math.ceil(needed_disk_gib / max_data_per_node_gib)
+
     cluster = compute_stateful_zone(
         instance=instance,
         drive=drive,
         needed_cores=int(requirement.cpu_cores.mid),
-        needed_disk_gib=requirement.disk_gib.mid,
+        needed_disk_gib=needed_disk_gib,
         needed_memory_gib=requirement.mem_gib.mid,
         needed_network_mbps=requirement.network_mbps.mid,
         # Take into account the reads per read
@@ -199,13 +216,9 @@ def _estimate_cockroachdb_cluster_zonal(  # noqa=E501 pylint: disable=too-many-p
             # TODO: presumably there are some write IOs here
             0,
         ),
-        # CRDB requires ephemeral disks to be 80% full because leveled
-        # compaction can make progress as long as there is some headroom
-        required_disk_space=lambda x: x * 1.2,
-        max_local_disk_gib=max_local_disk_gib,
         # cockroachdb clusters will autobalance across available nodes
         cluster_size=lambda x: x,
-        min_count=1,
+        min_count=min_count,
         # Sidecars/System takes away memory from cockroachdb
         # cockroachdb by default uses --max-sql-memory of 25% of system memory
         # that cannot be used for caching
@@ -268,6 +281,12 @@ class NflxCockroachDBArguments(BaseModel):
 
 
 class NflxCockroachDBCapacityModel(CapacityModel):
+    @staticmethod
+    def default_buffers() -> Buffers:
+        return Buffers(
+            default=Buffer(ratio=1.2),
+        )
+
     @staticmethod
     def capacity_plan(
         instance: Instance,
@@ -282,7 +301,11 @@ class NflxCockroachDBCapacityModel(CapacityModel):
         max_regional_size: int = extra_model_arguments.get("max_regional_size", 500)
         max_rps_to_disk: int = extra_model_arguments.get("max_rps_to_disk", 500)
         # Very large nodes are hard to recover
-        max_local_disk_gib: int = extra_model_arguments.get("max_local_disk_gib", 2048)
+        max_local_data_per_node_gib: int = extra_model_arguments.get(
+            "max_local_data_per_node_gib",
+            extra_model_arguments.get("max_local_disk_gib", 2048),
+        )
+
         # Cockroach Labs recommends a minimum of 8 vCPUs and strongly
         # recommends no fewer than 4 vCPUs per node.
         min_vcpu_per_instance: int = extra_model_arguments.get(
@@ -299,7 +322,7 @@ class NflxCockroachDBCapacityModel(CapacityModel):
             zones_per_region=context.zones_in_region,
             copies_per_region=copies_per_region,
             max_regional_size=max_regional_size,
-            max_local_disk_gib=max_local_disk_gib,
+            max_local_data_per_node_gib=max_local_data_per_node_gib,
             max_rps_to_disk=max_rps_to_disk,
             min_vcpu_per_instance=min_vcpu_per_instance,
             license_fee_per_core=license_fee_per_core,
@@ -330,6 +353,7 @@ class NflxCockroachDBCapacityModel(CapacityModel):
                     f"User asked for {key}={value}"
                 )
 
+        buffers = NflxCockroachDBCapacityModel.default_buffers()
         if user_desires.query_pattern.access_pattern == AccessPattern.latency:
             return CapacityDesires(
                 query_pattern=QueryPattern(
@@ -396,6 +420,7 @@ class NflxCockroachDBCapacityModel(CapacityModel):
                     # gateway taking about 1 MiB of memory
                     reserved_instance_app_mem_gib=0.001,
                 ),
+                buffers=buffers,
             )
         else:
             return CapacityDesires(
@@ -465,6 +490,7 @@ class NflxCockroachDBCapacityModel(CapacityModel):
                     # gateway taking about 1 MiB of memory
                     reserved_instance_app_mem_gib=0.001,
                 ),
+                buffers=buffers,
             )
 
 

service_capacity_modeling/models/org/netflix/elasticsearch.py

@@ -11,6 +11,9 @@ from pydantic import Field
 
 from service_capacity_modeling.interface import AccessConsistency
 from service_capacity_modeling.interface import AccessPattern
+from service_capacity_modeling.interface import Buffer
+from service_capacity_modeling.interface import BufferComponent
+from service_capacity_modeling.interface import Buffers
 from service_capacity_modeling.interface import CapacityDesires
 from service_capacity_modeling.interface import CapacityPlan
 from service_capacity_modeling.interface import CapacityRequirement
@@ -27,7 +30,9 @@ from service_capacity_modeling.interface import RegionContext
 from service_capacity_modeling.interface import Requirements
 from service_capacity_modeling.interface import ZoneClusterCapacity
 from service_capacity_modeling.models import CapacityModel
+from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
+from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
 from service_capacity_modeling.models.common import normalize_cores
 from service_capacity_modeling.models.common import simple_network_mbps
 from service_capacity_modeling.models.common import sqrt_staffed_cores
@@ -176,6 +181,20 @@ class NflxElasticsearchArguments(BaseModel):
 
 
 class NflxElasticsearchDataCapacityModel(CapacityModel):
+    @staticmethod
+    def default_buffers() -> Buffers:
+        return Buffers(
+            default=Buffer(ratio=1.33),
+        )
+
+    @staticmethod
+    def default_desires(
+        user_desires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
+        return CapacityDesires(
+            buffers=NflxElasticsearchDataCapacityModel.default_buffers()
+        )
+
     @staticmethod
     def capacity_plan(
         instance: Instance,
@@ -190,7 +209,10 @@ class NflxElasticsearchDataCapacityModel(CapacityModel):
         max_regional_size: int = extra_model_arguments.get("max_regional_size", 120)
         max_rps_to_disk: int = extra_model_arguments.get("max_rps_to_disk", 1000)
         # Very large nodes are hard to recover
-        max_local_disk_gib: int = extra_model_arguments.get("max_local_disk_gib", 8192)
+        max_local_data_per_node_gib: int = extra_model_arguments.get(
+            "max_local_data_per_node_gib",
+            extra_model_arguments.get("max_local_disk_gib", 8192),
+        )
 
         # the ratio of traffic that should be handled by search nodes.
         #  0.0 = no search nodes, all searches handled by data nodes
@@ -259,11 +281,23 @@ class NflxElasticsearchDataCapacityModel(CapacityModel):
         # io2/gp2 so for now we're just hardcoding.
         data_write_io_per_sec = (1 + 10) * max(1, data_write_bytes_per_sec // 16384)
 
+        disk_buffer_ratio = buffer_for_components(
+            buffers=desires.buffers, components=[BufferComponent.disk]
+        ).ratio
+        needed_disk_gib = data_requirement.disk_gib.mid * disk_buffer_ratio
+        max_data_per_node_gib = get_effective_disk_per_node_gib(
+            instance,
+            drive,
+            disk_buffer_ratio,
+            max_local_data_per_node_gib=max_local_data_per_node_gib,
+        )
+        min_count = math.ceil(needed_disk_gib / max_data_per_node_gib)
+
         data_cluster = compute_stateful_zone(
             instance=instance,
             drive=drive,
             needed_cores=int(data_requirement.cpu_cores.mid),
-            needed_disk_gib=int(data_requirement.disk_gib.mid),
+            needed_disk_gib=needed_disk_gib,
             needed_memory_gib=int(data_requirement.mem_gib.mid),
             needed_network_mbps=data_requirement.network_mbps.mid,
             # Take into account the reads per read
@@ -272,13 +306,9 @@ class NflxElasticsearchDataCapacityModel(CapacityModel):
                 _es_io_per_read(size) * math.ceil(data_rps / count),
                 data_write_io_per_sec / count,
             ),
-            # Elasticsearch requires ephemeral disks to be % full because tiered
-            # merging can make progress as long as there is some headroom
-            required_disk_space=lambda x: x * 1.33,
-            max_local_disk_gib=max_local_disk_gib,
             # Elasticsearch clusters can auto-balance via shard placement
             cluster_size=lambda x: x,
-            min_count=1,
+            min_count=min_count,
             # Sidecars/System takes away memory from Elasticsearch
             # which uses half of available system max of 32 for compressed oops
             reserve_memory=lambda x: base_mem + max(32, x / 2),

service_capacity_modeling/models/org/netflix/evcache.py

@@ -31,9 +31,11 @@ from service_capacity_modeling.interface import QueryPattern
 from service_capacity_modeling.interface import RegionContext
 from service_capacity_modeling.interface import Requirements
 from service_capacity_modeling.models import CapacityModel
+from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
 from service_capacity_modeling.models.common import get_cores_from_current_capacity
 from service_capacity_modeling.models.common import get_disk_from_current_capacity
+from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
 from service_capacity_modeling.models.common import get_memory_from_current_capacity
 from service_capacity_modeling.models.common import get_network_from_current_capacity
 from service_capacity_modeling.models.common import network_services
@@ -216,7 +218,7 @@ def _estimate_evcache_cluster_zonal(  # noqa: C901,E501 pylint: disable=too-many
     desires: CapacityDesires,
     context: RegionContext,
     copies_per_region: int = 3,
-    max_local_disk_gib: int = 2048,
+    max_local_data_per_node_gib: int = 2048,
     max_regional_size: int = 10000,
     min_instance_memory_gib: int = 12,
     cross_region_replication: Replication = Replication.none,
@@ -278,9 +280,9 @@ def _estimate_evcache_cluster_zonal(  # noqa: C901,E501 pylint: disable=too-many
     requirement.context["osmem"] = reserve_memory(instance.ram_gib)
     # EVCache clusters aim to be at least 2 nodes per zone to start
     # out with for tier 0
-    min_count = 0
+    min_count_for_tier = 0
     if desires.service_tier < 1:
-        min_count = 2
+        min_count_for_tier = 2
 
     is_disk_io_constraint: bool = requirement.disk_gib.mid > 0.0
     adjusted_disk_io_needed = 0.0
@@ -297,17 +299,25 @@ def _estimate_evcache_cluster_zonal(  # noqa: C901,E501 pylint: disable=too-many
         adjusted_disk_io_needed = 1.4 * adjusted_disk_io_needed
         read_write_ratio = reads_per_sec / (reads_per_sec + writes_per_sec)
 
+    needed_disk_gib = int(requirement.disk_gib.mid)
+    disk_buffer_ratio = buffer_for_components(
+        desires.buffers, [BufferComponent.disk]
+    ).ratio
+    max_data_per_node_gib = get_effective_disk_per_node_gib(
+        instance,
+        drive,
+        disk_buffer_ratio,
+        max_local_data_per_node_gib=max_local_data_per_node_gib,
+    )
+    min_count_for_data = math.ceil(needed_disk_gib / max_data_per_node_gib)
     cluster = compute_stateful_zone(
         instance=instance,
         drive=drive,
         needed_cores=int(requirement.cpu_cores.mid),
-        needed_disk_gib=int(requirement.disk_gib.mid),
+        needed_disk_gib=needed_disk_gib,
         needed_memory_gib=int(requirement.mem_gib.mid),
         needed_network_mbps=requirement.network_mbps.mid,
-        # EVCache doesn't use cloud drives to store data, we will have
-        # accounted for the data going on drives or memory via working set
-        max_local_disk_gib=max_local_disk_gib,
-        min_count=max(min_count, 0),
+        min_count=max(min_count_for_data, min_count_for_tier),
         adjusted_disk_io_needed=adjusted_disk_io_needed,
         read_write_ratio=read_write_ratio,
     )
@@ -411,8 +421,9 @@ class NflxEVCacheCapacityModel(CapacityModel):
         )
         max_regional_size: int = extra_model_arguments.get("max_regional_size", 10000)
         # Very large nodes are hard to cache warm
-        max_local_disk_gib: int = extra_model_arguments.get(
-            "max_local_disk_gib", 1024 * 6
+        max_local_data_per_node_gib: int = extra_model_arguments.get(
+            "max_local_data_per_node_gib",
+            extra_model_arguments.get("max_local_disk_gib", 1024 * 5),
         )
         # Very small nodes are hard to run memcache on
         # (Arun) We do not deploy to less than 12 GiB
@@ -429,7 +440,7 @@ class NflxEVCacheCapacityModel(CapacityModel):
             desires=desires,
             copies_per_region=copies_per_region,
             max_regional_size=max_regional_size,
-            max_local_disk_gib=max_local_disk_gib,
+            max_local_data_per_node_gib=max_local_data_per_node_gib,
             min_instance_memory_gib=min_instance_memory_gib,
             cross_region_replication=cross_region_replication,
             context=context,

service_capacity_modeling/models/org/netflix/kafka.py

@@ -34,8 +34,9 @@ from service_capacity_modeling.interface import QueryPattern
 from service_capacity_modeling.interface import RegionContext
 from service_capacity_modeling.interface import Requirements
 from service_capacity_modeling.models import CapacityModel
-from service_capacity_modeling.models import utils
+from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
+from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
 from service_capacity_modeling.models.common import normalize_cores
 from service_capacity_modeling.models.common import sqrt_staffed_cores
 from service_capacity_modeling.models.common import zonal_requirements_from_current
@@ -245,7 +246,8 @@ def _estimate_kafka_cluster_zonal(  # noqa: C901
     require_attached_disks: bool = False,
     required_zone_size: Optional[int] = None,
     max_regional_size: int = 150,
-    max_local_disk_gib: int = 1024 * 5,
+    max_local_data_per_node_gib: int = 2 * 1024,
+    max_attached_data_per_node_gib: int = 2 * 1024,
     min_instance_cpu: int = 2,
     min_instance_memory_gib: int = 12,
     require_same_instance_family: bool = True,
@@ -291,9 +293,9 @@ def _estimate_kafka_cluster_zonal(  # noqa: C901
     )
 
     # Kafka clusters in prod (tier 0+1) need at least 2 nodes per zone
-    min_count = 1
+    min_count_for_tier = 1
     if desires.service_tier < 2:
-        min_count = 2
+        min_count_for_tier = 2
 
     # Kafka read io / second is zonal
     normalized_to_mib = desires.model_copy(deep=True)
@@ -313,8 +315,19 @@ def _estimate_kafka_cluster_zonal(  # noqa: C901
     write_ios_per_second = max(
         1, (write_mib_per_second * 1024) // drive.seq_io_size_kib
     )
-    max_attached_disk_gib = 8 * 1024
 
+    needed_disk_gib = int(requirement.disk_gib.mid)
+    disk_buffer_ratio = buffer_for_components(
+        buffers=desires.buffers, components=[BufferComponent.disk]
+    ).ratio
+    max_disk_per_node_gib = get_effective_disk_per_node_gib(
+        instance,
+        drive,
+        disk_buffer_ratio,
+        max_local_data_per_node_gib=max_local_data_per_node_gib,
+        max_attached_data_per_node_gib=max_attached_data_per_node_gib,
+    )
+    min_count_for_data = math.ceil(needed_disk_gib / max_disk_per_node_gib)
     cluster = compute_stateful_zone(
         instance=instance,
         drive=drive,
@@ -337,16 +350,11 @@ def _estimate_kafka_cluster_zonal(  # noqa: C901
             # Leave 100% IO headroom for writes
             copies_per_region * (write_ios_per_second / count) * 2,
         ),
-        # Disk buffer is already added when computing kafka disk requirements
-        required_disk_space=lambda x: x,
-        max_local_disk_gib=max_local_disk_gib,
         cluster_size=lambda x: x,
-        min_count=max(min_count, required_zone_size or 1),
+        min_count=max(min_count_for_tier, min_count_for_data, required_zone_size or 1),
         # Sidecars and Variable OS Memory
         # Kafka currently uses 8GiB fixed, might want to change to min(30, x // 2)
         reserve_memory=lambda instance_mem_gib: base_mem + 8,
-        # allow up to 8TiB of attached EBS
-        max_attached_disk_gib=max_attached_disk_gib,
     )
 
     # Communicate to the actual provision that if we want reduced RF
@@ -355,28 +363,18 @@ def _estimate_kafka_cluster_zonal(  # noqa: C901
 
     # This is roughly the disk we would have tried to provision with the current
     # cluster's instance count (or required_zone_size)
-    if required_zone_size is not None:
-        space_gib = max(1, math.ceil(requirement.disk_gib.mid / required_zone_size))
-        ebs_gib = utils.next_n(space_gib, n=100)
-
-        # Max allowed disk size in `compute_stateful_zone`
-        if instance.drive is not None and instance.drive.size_gib > 0:
-            max_size = min(max_local_disk_gib, instance.drive.size_gib)
-        elif max_attached_disk_gib is not None:
-            max_size = max_attached_disk_gib
-        else:
-            max_size = drive.max_size_gib / 3
-
-        # Capacity planner only allows ~ 5TB disk (max_size) for gp3 drives
-        # or max_attached_disk_gib if provided.
-        # If ebs_gib > max_size, we do not have enough instances within the
-        # required_zone_size for the required disk. In these cases, it is
-        # not possible for cluster.count == required_zone_size. We should
-        # allow higher instance count for these cases so that we return some result
-        # If we did not exceed the max disk size with the required_zone_size, then
-        # we only allow topologies that match the desired zone size
-        if ebs_gib <= max_size and cluster.count != required_zone_size:
-            return None
+    # If we *could* have satisified the required_zone_size without exceeding the
+    # max data size per node constraints but the actual cluster count does not
+    # match the required_zone_size, then we want to omit the plan
+    # However if there was no way to satisfy the required_zone_size with the
+    # max data size per node constraints, then we would rather return some result
+    # with a higher instance count since this is the best we can do
+    if (
+        required_zone_size is not None
+        and min_count_for_data <= required_zone_size
+        and cluster.count != required_zone_size
+    ):
+        return None
 
     # Kafka clusters generally should try to stay under some total number
     # of nodes. Orgs do this for all kinds of reasons such as
@@ -491,8 +489,9 @@ class NflxKafkaCapacityModel(CapacityModel):
 
         max_regional_size: int = extra_model_arguments.get("max_regional_size", 150)
         # Very large nodes are hard to cache warm
-        max_local_disk_gib: int = extra_model_arguments.get(
-            "max_local_disk_gib", 1024 * 5
+        max_local_data_per_node_gib: int = extra_model_arguments.get(
+            "max_local_data_per_node_gib",
+            extra_model_arguments.get("max_local_disk_gib", 1024 * 2),
         )
         min_instance_cpu: int = extra_model_arguments.get("min_instance_cpu", 2)
         min_instance_memory_gib: int = extra_model_arguments.get(
@@ -525,7 +524,7 @@ class NflxKafkaCapacityModel(CapacityModel):
             require_attached_disks=require_attached_disks,
             required_zone_size=required_zone_size,
             max_regional_size=max_regional_size,
-            max_local_disk_gib=max_local_disk_gib,
+            max_local_data_per_node_gib=max_local_data_per_node_gib,
             min_instance_cpu=min_instance_cpu,
             min_instance_memory_gib=min_instance_memory_gib,
             hot_retention_seconds=hot_retention_seconds,

service_capacity_modeling/models/utils.py

@@ -62,5 +62,21 @@ def next_power_of_2(y: float) -> int:
     return 1 if x == 0 else 2 ** (x - 1).bit_length()
 
 
+def is_power_of_2(y: float) -> bool:
+    """Check if x is a power of 2 or 1"""
+    return y == next_power_of_2(y)
+
+
+def next_doubling(x: float, base: int) -> int:
+    # Some clusters were provisioned as non powers of (e.g. 12)
+    # And so if a requirement cannot be satisifed by a cluster
+    # we would want to round up to the next doubling
+    # E.g. 12 -> 24 -> 48
+    # e.g. 3 -> 6 -> 12
+    if x <= base:
+        return int(base)
+    return int(base * (2 ** math.ceil(math.log(x / base, 2))))
+
+
 def next_n(x: float, n: float) -> int:
     return int(math.ceil(x / n)) * int(n)

service_capacity_modeling/tools/generate_missing.py

@@ -29,7 +29,9 @@ def build_command(family: str, params: Dict[str, Any], output_path: Path) -> lis
         cmd.extend(["--io-latency-curve", params["io_latency_curve"]])
 
     if params.get("cpu_ipc_scale") is not None:
-        cmd.extend(["--cpu-ipc-scale", str(params["cpu_ipc_scale"])])
+        cpu_ipc_scale = float(params["cpu_ipc_scale"])
+        rounded_cpu_ipc_scale = float(f"{cpu_ipc_scale:.2f}")
+        cmd.extend(["--cpu-ipc-scale", str(rounded_cpu_ipc_scale)])
 
     # Add output path
     cmd.extend(["--output-path", str(output_path)])

{service_capacity_modeling-0.3.68.dist-info → service_capacity_modeling-0.3.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: service-capacity-modeling
-Version: 0.3.68
+Version: 0.3.70
 Summary: Contains utilities for modeling capacity for pluggable workloads
 Author: Joseph Lynch
 Author-email: josephl@netflix.com

{service_capacity_modeling-0.3.68.dist-info → service_capacity_modeling-0.3.70.dist-info}/RECORD

@@ -40,22 +40,22 @@ service_capacity_modeling/hardware/profiles/shapes/aws/manual_drives.json,sha256
 service_capacity_modeling/hardware/profiles/shapes/aws/manual_instances.json,sha256=i611n6d7hsjd7L8aSEDzfaTMS2jVs-Jc38-vl-NKfs4,18013
 service_capacity_modeling/hardware/profiles/shapes/aws/manual_services.json,sha256=h63675KKmu5IrI3BORDN8fiAqLjAyYHArErKbC7-T30,776
 service_capacity_modeling/models/__init__.py,sha256=XK7rTBW8ZXQY5L9Uy2FwjuFN_KBW3hKw7IrhG1piajs,13567
-service_capacity_modeling/models/common.py,sha256=P4NrPbAdgNKqvVNFUfpocG44Dw8ai9jEDuYIGzRGCRM,33549
+service_capacity_modeling/models/common.py,sha256=oF1WVhd6kXFvKNs7zzkms25U1Si_iqCn48TptyxWd0E,34128
 service_capacity_modeling/models/headroom_strategy.py,sha256=QIkP_K_tK2EGAjloaGfXeAPH5M0UDCN8FlAtwV9xxTA,651
-service_capacity_modeling/models/utils.py,sha256=0F__wz9KAGhPIQfvNp-FTtTANW6-sO4FsyddnuXqSJc,2161
+service_capacity_modeling/models/utils.py,sha256=WosEEg4o1_WSbTb5mL-M1v8JuWJgvS2oWvnDS3qNz3k,2662
 service_capacity_modeling/models/org/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 service_capacity_modeling/models/org/netflix/__init__.py,sha256=m7IaQbo85NEbDvfoPJREIznpzg0YHTCrKP5C1GvnOYM,2378
 service_capacity_modeling/models/org/netflix/aurora.py,sha256=Mi9zd48k64GkKIjAs3J1S2qThguNvyWIy2dUmhwrVhc,12883
-service_capacity_modeling/models/org/netflix/cassandra.py,sha256=TetxgkoZ0hTprXX1GxWpBbOWZdHPtk9VqOi1B6ZeNnw,34569
+service_capacity_modeling/models/org/netflix/cassandra.py,sha256=QdSurxiv9XiCK7z6Omn6hjZf0rHleDfMvn3-JSpr5rA,38548
 service_capacity_modeling/models/org/netflix/counter.py,sha256=hOVRRCgCPU-A5TdLKQXc_mWTQpkKOWRNjOeECdDP7kA,9205
-service_capacity_modeling/models/org/netflix/crdb.py,sha256=AlHdGFpR1RmwQSZsiuiHLR2wTrnmtguT2MMYBDHfdiM,19697
+service_capacity_modeling/models/org/netflix/crdb.py,sha256=ELIbxwfNsJcEkNGW7qtz0SEzt3Vj6wj8QL5QQeebIlo,20635
 service_capacity_modeling/models/org/netflix/ddb.py,sha256=GDoXVIpDDY6xDB0dsiaz7RAPPj-qffTrM9N6w5-5ndg,26311
-service_capacity_modeling/models/org/netflix/elasticsearch.py,sha256=746WYY_WSeMgY-Go7wvWGYOxfFV8ryupNThvDZHPbGo,23685
+service_capacity_modeling/models/org/netflix/elasticsearch.py,sha256=mYmr6DA3EyqXCsEhwJArK_VsUDLq5Pi3E8jUUEfhnRM,24729
 service_capacity_modeling/models/org/netflix/entity.py,sha256=M0vzwhf8UAbVxnXspAkN4GEbq3rix6yoky6W2oDG6a0,8648
-service_capacity_modeling/models/org/netflix/evcache.py,sha256=isONE5UF-b8gCgdGB1iMYOrwgKAHghYJiyoBfcYJ1ac,25246
+service_capacity_modeling/models/org/netflix/evcache.py,sha256=70lgaRgNwJH84o6JVoUDplkCi4v-WzEX3nxVagoJjDc,25775
 service_capacity_modeling/models/org/netflix/graphkv.py,sha256=iS5QDDv9_hNY6nIgdL-umB439qP7-jN-n6_Tl6d-ZSo,8557
 service_capacity_modeling/models/org/netflix/iso_date_math.py,sha256=CPGHLmbGeNqkcYcmCkLKhPZcAU-yTJ2HjvuXdnNyCYc,996
-service_capacity_modeling/models/org/netflix/kafka.py,sha256=FiuBml8uWOVfPFZ37NvZW13nMVtFE4VDf_SZIFdw4sA,25515
+service_capacity_modeling/models/org/netflix/kafka.py,sha256=MDHaht5cWsOJ113uMl6nQ7nllSATrlBCQ-TXLkqMWEk,25466
 service_capacity_modeling/models/org/netflix/key_value.py,sha256=yL5moU0SJD4ocBU9zeGhPYE4KY7oSSq5yqfVWd_Ot2g,9336
 service_capacity_modeling/models/org/netflix/postgres.py,sha256=R3Tog-ZW1Yx6gO3AKqI_wquSm30s01QX9yWR7Jvgk9A,4055
 service_capacity_modeling/models/org/netflix/rds.py,sha256=z9egFBg4Ltqyuz_WHk-_hw-xL-EQNzl1JopJoWdNli8,10768
@@ -67,11 +67,11 @@ service_capacity_modeling/models/org/netflix/zookeeper.py,sha256=BHLjnVDyx15wMGr
 service_capacity_modeling/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 service_capacity_modeling/tools/auto_shape.py,sha256=41pfR40BN-xJS8js4BWSoqT67JhO2_XqzmNeKDoCFBo,14674
 service_capacity_modeling/tools/fetch_pricing.py,sha256=JkgJPTE0SVj8sdGQvo0HN-Hdv3nfA2tu7C_Arad5aX8,3762
-service_capacity_modeling/tools/generate_missing.py,sha256=uvr9fQanx3bm4KTneH-x7EOQvO7cVV0i9gdQvArPCuY,2947
+service_capacity_modeling/tools/generate_missing.py,sha256=XqUs54CPfli4XtK0rEiFKqDvpwCiMAD8wrl7fAxpYHs,3062
 service_capacity_modeling/tools/instance_families.py,sha256=e9JWSIdljSmHI8Nb2MI5Ld9JqQ7WdOtPtV7g3oR7ZiU,7764
-service_capacity_modeling-0.3.68.dist-info/licenses/LICENSE,sha256=nl_Lt5v9VvJ-5lWJDT4ddKAG-VZ-2IaLmbzpgYDz2hU,11343
-service_capacity_modeling-0.3.68.dist-info/METADATA,sha256=6Dp2jy5MMYu0UuOser41xX75P0Nov_6tC65J8l4wHEs,10214
-service_capacity_modeling-0.3.68.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-service_capacity_modeling-0.3.68.dist-info/entry_points.txt,sha256=ZsjzpG5SomWpT1zCE19n1uSXKH2gTI_yc33sdl0vmJg,146
-service_capacity_modeling-0.3.68.dist-info/top_level.txt,sha256=H8XjTCLgR3enHq5t3bIbxt9SeUkUT8HT_SDv2dgIT_A,26
-service_capacity_modeling-0.3.68.dist-info/RECORD,,
+service_capacity_modeling-0.3.70.dist-info/licenses/LICENSE,sha256=nl_Lt5v9VvJ-5lWJDT4ddKAG-VZ-2IaLmbzpgYDz2hU,11343
+service_capacity_modeling-0.3.70.dist-info/METADATA,sha256=-cFPJXpSY6SNZZD0hZTLlF9Lauq6PW083xJpBDwSIXA,10214
+service_capacity_modeling-0.3.70.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+service_capacity_modeling-0.3.70.dist-info/entry_points.txt,sha256=ZsjzpG5SomWpT1zCE19n1uSXKH2gTI_yc33sdl0vmJg,146
+service_capacity_modeling-0.3.70.dist-info/top_level.txt,sha256=H8XjTCLgR3enHq5t3bIbxt9SeUkUT8HT_SDv2dgIT_A,26
+service_capacity_modeling-0.3.70.dist-info/RECORD,,