skypilot-nightly 1.0.0.dev20240912__tar.gz → 1.0.0.dev20240913__tar.gz

{skypilot_nightly-1.0.0.dev20240912/skypilot_nightly.egg-info → skypilot_nightly-1.0.0.dev20240913}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skypilot-nightly
-Version: 1.0.0.dev20240912
+Version: 1.0.0.dev20240913
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0

{skypilot_nightly-1.0.0.dev20240912 → skypilot_nightly-1.0.0.dev20240913}/sky/__init__.py

@@ -5,7 +5,7 @@ from typing import Optional
 import urllib.request
 
 # Replaced with the current commit when building the wheels.
-_SKYPILOT_COMMIT_SHA = '49b27fc889efa20ca688909b624f01da214a7be8'
+_SKYPILOT_COMMIT_SHA = '8f4eef4ee46853d1afccd655135804b6742e368e'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20240912'
+__version__ = '1.0.0.dev20240913'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 

{skypilot_nightly-1.0.0.dev20240912 → skypilot_nightly-1.0.0.dev20240913}/sky/clouds/gcp.py

@@ -424,6 +424,21 @@ class GCP(clouds.Cloud):
         # issue when first booted.
         image_id = 'skypilot:cpu-debian-11'
 
+        def _failover_disk_tier() -> Optional[resources_utils.DiskTier]:
+            if (r.disk_tier is not None and
+                    r.disk_tier != resources_utils.DiskTier.BEST):
+                return r.disk_tier
+            # Failover disk tier from ultra to low.
+            all_tiers = list(reversed(resources_utils.DiskTier))
+            start_index = all_tiers.index(GCP._translate_disk_tier(r.disk_tier))
+            while start_index < len(all_tiers):
+                disk_tier = all_tiers[start_index]
+                ok, _ = GCP.check_disk_tier(r.instance_type, disk_tier)
+                if ok:
+                    return disk_tier
+                start_index += 1
+            assert False, 'Low disk tier should always be supported on GCP.'
+
         r = resources
         # Find GPU spec, if any.
         resources_vars = {
@@ -437,7 +452,7 @@ class GCP(clouds.Cloud):
             'custom_resources': None,
             'use_spot': r.use_spot,
             'gcp_project_id': self.get_project_id(dryrun),
-            **GCP._get_disk_specs(r.disk_tier),
+            **GCP._get_disk_specs(_failover_disk_tier()),
         }
         accelerators = r.accelerators
         if accelerators is not None:
@@ -532,6 +547,10 @@ class GCP(clouds.Cloud):
     ) -> 'resources_utils.FeasibleResources':
         if resources.instance_type is not None:
             assert resources.is_launchable(), resources
+            ok, _ = GCP.check_disk_tier(resources.instance_type,
+                                        resources.disk_tier)
+            if not ok:
+                return resources_utils.FeasibleResources([], [], None)
             return resources_utils.FeasibleResources([resources], [], None)
 
         if resources.accelerators is None:
@@ -544,15 +563,17 @@ class GCP(clouds.Cloud):
                 # TODO: Add hints to all return values in this method to help
                 #  users understand why the resources are not launchable.
                 return resources_utils.FeasibleResources([], [], None)
-            else:
-                r = resources.copy(
-                    cloud=GCP(),
-                    instance_type=host_vm_type,
-                    accelerators=None,
-                    cpus=None,
-                    memory=None,
-                )
-                return resources_utils.FeasibleResources([r], [], None)
+            ok, _ = GCP.check_disk_tier(host_vm_type, resources.disk_tier)
+            if not ok:
+                return resources_utils.FeasibleResources([], [], None)
+            r = resources.copy(
+                cloud=GCP(),
+                instance_type=host_vm_type,
+                accelerators=None,
+                cpus=None,
+                memory=None,
+            )
+            return resources_utils.FeasibleResources([r], [], None)
 
         # Find instance candidates to meet user's requirements
         assert len(resources.accelerators.items()
@@ -615,6 +636,10 @@ class GCP(clouds.Cloud):
         else:
             host_vm_type = instance_list[0]
 
+        ok, _ = GCP.check_disk_tier(host_vm_type, resources.disk_tier)
+        if not ok:
+            return resources_utils.FeasibleResources([], fuzzy_candidate_list,
+                                                     None)
         acc_dict = {acc: acc_count}
         r = resources.copy(
             cloud=GCP(),
@@ -916,6 +941,36 @@ class GCP(clouds.Cloud):
             resources.instance_type, resources.accelerators, resources.zone,
             'gcp')
 
+    @classmethod
+    def check_disk_tier(
+            cls, instance_type: Optional[str],
+            disk_tier: Optional[resources_utils.DiskTier]) -> Tuple[bool, str]:
+        if disk_tier != resources_utils.DiskTier.ULTRA or instance_type is None:
+            return True, ''
+        # Ultra disk tier (pd-extreme) only support m2, m3 and part of n2
+        # instance types, so we failover to lower tiers for other instance
+        # types. Reference:
+        # https://cloud.google.com/compute/docs/disks/extreme-persistent-disk#machine_shape_support  # pylint: disable=line-too-long
+        series = instance_type.split('-')[0]
+        if series in ['m2', 'm3', 'n2']:
+            if series == 'n2':
+                num_cpus = int(instance_type.split('-')[2])
+                if num_cpus < 64:
+                    return False, ('n2 series with less than 64 vCPUs are '
+                                   'not supported with pd-extreme.')
+            return True, ''
+        return False, (f'{series} series is not supported with pd-extreme. '
+                       'Only m2, m3 series and n2 series with 64 or more vCPUs '
+                       'are supported.')
+
+    @classmethod
+    def check_disk_tier_enabled(cls, instance_type: Optional[str],
+                                disk_tier: resources_utils.DiskTier) -> None:
+        ok, msg = cls.check_disk_tier(instance_type, disk_tier)
+        if not ok:
+            with ux_utils.print_exception_no_traceback():
+                raise exceptions.NotSupportedError(msg)
+
     @classmethod
     def _get_disk_type(cls,
                        disk_tier: Optional[resources_utils.DiskTier]) -> str:

{skypilot_nightly-1.0.0.dev20240912 → skypilot_nightly-1.0.0.dev20240913}/sky/clouds/service_catalog/data_fetchers/fetch_gcp.py

@@ -10,6 +10,7 @@ import io
 import multiprocessing
 import os
 import textwrap
+import time
 import typing
 from typing import Any, Callable, Dict, List, Optional, Set
 
@@ -19,6 +20,7 @@ import numpy as np
 
 from sky.adaptors import common as adaptors_common
 from sky.adaptors import gcp
+from sky.utils import common_utils
 
 if typing.TYPE_CHECKING:
     import pandas as pd
@@ -38,6 +40,9 @@ TPU_SERVICE_ID = 'E000-3F24-B8AA'
 # The number of digits to round the price to.
 PRICE_ROUNDING = 5
 
+# The number of retries for the TPU API.
+TPU_RETRY_CNT = 3
+
 # This zone is only for TPU v4, and does not appear in the skus yet.
 TPU_V4_ZONES = ['us-central2-b']
 # TPU v3 pods are available in us-east1-d, but hidden in the skus.
@@ -518,6 +523,34 @@ def get_gpu_df(skus: List[Dict[str, Any]],
     return df
 
 
+def _get_tpu_response_for_zone(zone: str) -> list:
+    parent = f'projects/{project_id}/locations/{zone}'
+    # Sometimes the response is empty ({}) even for enabled zones. Here we
+    # retry the request for a few times.
+    backoff = common_utils.Backoff(initial_backoff=1)
+    for _ in range(TPU_RETRY_CNT):
+        tpus_request = (
+            tpu_client.projects().locations().acceleratorTypes().list(
+                parent=parent))
+        try:
+            tpus_response = tpus_request.execute()
+            if 'acceleratorTypes' in tpus_response:
+                return tpus_response['acceleratorTypes']
+        except gcp.http_error_exception() as error:
+            if error.resp.status == 403:
+                print('  TPU API is not enabled or you don\'t have TPU access '
+                      f'to zone: {zone!r}.')
+            else:
+                print(f'  An error occurred: {error}')
+            # If error happens, fail early.
+            return []
+        time_to_sleep = backoff.current_backoff()
+        print(f'  Retry zone {zone!r} in {time_to_sleep} seconds...')
+        time.sleep(time_to_sleep)
+    print(f'ERROR: Failed to fetch TPUs for zone {zone!r}.')
+    return []
+
+
 def _get_tpu_for_zone(zone: str) -> 'pd.DataFrame':
     # Use hardcoded TPU V5 data as it is invisible in some zones.
     missing_tpus_df = pd.DataFrame(columns=[
@@ -526,19 +559,8 @@ def _get_tpu_for_zone(zone: str) -> 'pd.DataFrame':
     if zone in TPU_V5_MISSING_ZONES_DF:
         missing_tpus_df = TPU_V5_MISSING_ZONES_DF[zone]
     tpus = []
-    parent = f'projects/{project_id}/locations/{zone}'
-    tpus_request = tpu_client.projects().locations().acceleratorTypes().list(
-        parent=parent)
-    try:
-        tpus_response = tpus_request.execute()
-        for tpu in tpus_response['acceleratorTypes']:
-            tpus.append(tpu)
-    except gcp.http_error_exception() as error:
-        if error.resp.status == 403:
-            print('  TPU API is not enabled or you don\'t have TPU access '
-                  f'to zone: {zone!r}.')
-        else:
-            print(f'  An error occurred: {error}')
+    for tpu in _get_tpu_response_for_zone(zone):
+        tpus.append(tpu)
     new_tpus = []
     for tpu in tpus:
         tpu_name = tpu['type']

{skypilot_nightly-1.0.0.dev20240912 → skypilot_nightly-1.0.0.dev20240913}/sky/clouds/service_catalog/gcp_catalog.py

@@ -9,6 +9,7 @@ from typing import Dict, List, Optional, Tuple
 from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
+from sky.clouds import GCP
 from sky.clouds.service_catalog import common
 from sky.utils import resources_utils
 from sky.utils import ux_utils
@@ -243,7 +244,6 @@ def get_default_instance_type(
         cpus: Optional[str] = None,
         memory: Optional[str] = None,
         disk_tier: Optional[resources_utils.DiskTier] = None) -> Optional[str]:
-    del disk_tier  # unused
     if cpus is None and memory is None:
         cpus = f'{_DEFAULT_NUM_VCPUS}+'
     if memory is None:
@@ -254,6 +254,12 @@ def get_default_instance_type(
         f'{family}-' for family in _DEFAULT_INSTANCE_FAMILY)
     df = _df[_df['InstanceType'].notna()]
     df = df[df['InstanceType'].str.startswith(instance_type_prefix)]
+
+    def _filter_disk_type(instance_type: str) -> bool:
+        valid, _ = GCP.check_disk_tier(instance_type, disk_tier)
+        return valid
+
+    df = df.loc[df['InstanceType'].apply(_filter_disk_type)]
     return common.get_instance_type_for_cpus_mem_impl(df, cpus,
                                                       memory_gb_or_ratio)
 

{skypilot_nightly-1.0.0.dev20240912 → skypilot_nightly-1.0.0.dev20240913/skypilot_nightly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skypilot-nightly
-Version: 1.0.0.dev20240912
+Version: 1.0.0.dev20240913
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0