skypilot-nightly 1.0.0.dev20250113__tar.gz → 1.0.0.dev20250115__tar.gz

{skypilot_nightly-1.0.0.dev20250113/skypilot_nightly.egg-info → skypilot_nightly-1.0.0.dev20250115}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: skypilot-nightly
-Version: 1.0.0.dev20250113
+Version: 1.0.0.dev20250115
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0
@@ -351,6 +351,8 @@ Read the research:
 - [Sky Computing vision paper](https://sigops.org/s/conferences/hotos/2021/papers/hotos21-s02-stoica.pdf) (HotOS 2021)
 - [Policy for Managed Spot Jobs](https://www.usenix.org/conference/nsdi24/presentation/wu-zhanghao)  (NSDI 2024)
 
+SkyPilot was initially started at the [Sky Computing Lab](https://sky.cs.berkeley.edu) at UC Berkeley and has since gained many industry contributors. Read more about the project's origin [here](https://docs.skypilot.co/en/latest/sky-computing.html).
+
 ## Support and Questions
 We are excited to hear your feedback!
 * For issues and feature requests, please [open a GitHub issue](https://github.com/skypilot-org/skypilot/issues/new).

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/README.md

@@ -199,6 +199,8 @@ Read the research:
 - [Sky Computing vision paper](https://sigops.org/s/conferences/hotos/2021/papers/hotos21-s02-stoica.pdf) (HotOS 2021)
 - [Policy for Managed Spot Jobs](https://www.usenix.org/conference/nsdi24/presentation/wu-zhanghao)  (NSDI 2024)
 
+SkyPilot was initially started at the [Sky Computing Lab](https://sky.cs.berkeley.edu) at UC Berkeley and has since gained many industry contributors. Read more about the project's origin [here](https://docs.skypilot.co/en/latest/sky-computing.html).
+
 ## Support and Questions
 We are excited to hear your feedback!
 * For issues and feature requests, please [open a GitHub issue](https://github.com/skypilot-org/skypilot/issues/new).

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/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 = 'fd1ac0e6fbde830ac6be9e42f523a0e460fd84e8'
+_SKYPILOT_COMMIT_SHA = 'd9bb51a66a33ed06f9f0c791ac3ed5ad93ffa587'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250113'
+__version__ = '1.0.0.dev20250115'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/adaptors/common.py

@@ -1,6 +1,7 @@
 """Lazy import for modules to avoid import error when not used."""
 import functools
 import importlib
+import threading
 from typing import Any, Callable, Optional, Tuple
 
 
@@ -24,17 +25,22 @@ class LazyImport:
         self._module = None
         self._import_error_message = import_error_message
         self._set_loggers = set_loggers
+        self._lock = threading.RLock()
 
     def load_module(self):
-        if self._module is None:
-            try:
-                self._module = importlib.import_module(self._module_name)
-                if self._set_loggers is not None:
-                    self._set_loggers()
-            except ImportError as e:
-                if self._import_error_message is not None:
-                    raise ImportError(self._import_error_message) from e
-                raise
+        # Avoid extra imports when multiple threads try to import the same
+        # module. The overhead is minor since import can only run in serial
+        # due to GIL even in multi-threaded environments.
+        with self._lock:
+            if self._module is None:
+                try:
+                    self._module = importlib.import_module(self._module_name)
+                    if self._set_loggers is not None:
+                        self._set_loggers()
+                except ImportError as e:
+                    if self._import_error_message is not None:
+                        raise ImportError(self._import_error_message) from e
+                    raise
         return self._module
 
     def __getattr__(self, name: str) -> Any:

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/backends/cloud_vm_ray_backend.py

@@ -3327,7 +3327,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
         # even if some of them raise exceptions. We should replace it with
         # multi-process.
         rich_utils.stop_safe_status()
-        subprocess_utils.run_in_parallel(_setup_node, range(num_nodes))
+        subprocess_utils.run_in_parallel(_setup_node, list(range(num_nodes)))
 
         if detach_setup:
             # Only set this when setup needs to be run outside the self._setup()

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/clouds/service_catalog/__init__.py

@@ -10,6 +10,7 @@ from sky.clouds.service_catalog.constants import CATALOG_DIR
 from sky.clouds.service_catalog.constants import CATALOG_SCHEMA_VERSION
 from sky.clouds.service_catalog.constants import HOSTED_CATALOG_DIR_URL
 from sky.utils import resources_utils
+from sky.utils import subprocess_utils
 
 if typing.TYPE_CHECKING:
     from sky.clouds import cloud
@@ -31,8 +32,7 @@ def _map_clouds_catalog(clouds: CloudFilter, method_name: str, *args, **kwargs):
     if single:
         clouds = [clouds]  # type: ignore
 
-    results = []
-    for cloud in clouds:
+    def _execute_catalog_method(cloud: str):
         try:
             cloud_module = importlib.import_module(
                 f'sky.clouds.service_catalog.{cloud.lower()}_catalog')
@@ -46,7 +46,11 @@ def _map_clouds_catalog(clouds: CloudFilter, method_name: str, *args, **kwargs):
             raise AttributeError(
                 f'Module "{cloud}_catalog" does not '
                 f'implement the "{method_name}" method') from None
-        results.append(method(*args, **kwargs))
+        return method(*args, **kwargs)
+
+    results = subprocess_utils.run_in_parallel(_execute_catalog_method,
+                                               args=list(clouds),
+                                               num_threads=len(clouds))
     if single:
         return results[0]
     return results

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/clouds/service_catalog/kubernetes_catalog.py

@@ -115,6 +115,16 @@ def _list_accelerators(
 
     If the user does not have sufficient permissions to list pods in all
     namespaces, the function will return free GPUs as -1.
+
+    Returns:
+        A tuple of three dictionaries:
+        - qtys_map: Dict mapping accelerator names to lists of InstanceTypeInfo
+            objects with quantity information.
+        - total_accelerators_capacity: Dict mapping accelerator names to their
+            total capacity in the cluster.
+        - total_accelerators_available: Dict mapping accelerator names to their
+            current availability. Returns -1 for each accelerator if
+            realtime=False or if insufficient permissions.
     """
     # TODO(romilb): This should be refactored to use get_kubernetes_node_info()
     #   function from kubernetes_utils.
@@ -243,6 +253,10 @@ def _list_accelerators(
 
                 accelerators_available = accelerator_count - allocated_qty
 
+                # Initialize the entry if it doesn't exist yet
+                if accelerator_name not in total_accelerators_available:
+                    total_accelerators_available[accelerator_name] = 0
+
                 if accelerators_available >= min_quantity_filter:
                     quantized_availability = min_quantity_filter * (
                         accelerators_available // min_quantity_filter)

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/data/mounting_utils.py

@@ -122,15 +122,21 @@ def get_az_mount_cmd(container_name: str,
     cache_path = _BLOBFUSE_CACHE_DIR.format(
         storage_account_name=storage_account_name,
         container_name=container_name)
+    # The line below ensures the cache directory is new before mounting to
+    # avoid "config error in file_cache [temp directory not empty]" error, which
+    # can occur after stopping and starting the same cluster on Azure.
+    # This helps ensure a clean state for blobfuse2 operations.
+    remote_boot_time_cmd = 'date +%s -d "$(uptime -s)"'
     if _bucket_sub_path is None:
         bucket_sub_path_arg = ''
     else:
         bucket_sub_path_arg = f'--subdirectory={_bucket_sub_path}/ '
+    # TODO(zpoint): clear old cache that has been created in the previous boot.
     mount_cmd = (f'AZURE_STORAGE_ACCOUNT={storage_account_name} '
                  f'{key_env_var} '
                  f'blobfuse2 {mount_path} --allow-other --no-symlinks '
                  '-o umask=022 -o default_permissions '
-                 f'--tmp-path {cache_path} '
+                 f'--tmp-path {cache_path}_$({remote_boot_time_cmd}) '
                  f'{bucket_sub_path_arg}'
                  f'--container-name {container_name}')
     return mount_cmd

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/optimizer.py

@@ -1293,9 +1293,12 @@ def _fill_in_launchable_resources(
                        if resources.cloud is not None else enabled_clouds)
         # If clouds provide hints, store them for later printing.
         hints: Dict[clouds.Cloud, str] = {}
-        for cloud in clouds_list:
-            feasible_resources = cloud.get_feasible_launchable_resources(
-                resources, num_nodes=task.num_nodes)
+
+        feasible_list = subprocess_utils.run_in_parallel(
+            lambda cloud, r=resources, n=task.num_nodes:
+            (cloud, cloud.get_feasible_launchable_resources(r, n)),
+            clouds_list)
+        for cloud, feasible_resources in feasible_list:
             if feasible_resources.hint is not None:
                 hints[cloud] = feasible_resources.hint
             if feasible_resources.resources_list:

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/provision/azure/instance.py

@@ -343,7 +343,7 @@ def _create_instances(compute_client: 'azure_compute.ComputeManagementClient',
         _create_vm(compute_client, vm_name, node_tags, provider_config,
                    node_config, network_interface.id)
 
-    subprocess_utils.run_in_parallel(create_single_instance, range(count))
+    subprocess_utils.run_in_parallel(create_single_instance, list(range(count)))
 
     # Update disk performance tier
     performance_tier = node_config.get('disk_performance_tier', None)

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/provision/kubernetes/instance.py

@@ -804,7 +804,8 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
 
     # Create pods in parallel
     pods = subprocess_utils.run_in_parallel(_create_pod_thread,
-                                            range(to_start_count), _NUM_THREADS)
+                                            list(range(to_start_count)),
+                                            _NUM_THREADS)
 
     # Process created pods
     for pod in pods:

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/usage/usage_lib.py

@@ -3,7 +3,6 @@
 import contextlib
 import datetime
 import enum
-import inspect
 import json
 import os
 import time
@@ -12,19 +11,28 @@ import typing
 from typing import Any, Callable, Dict, List, Optional, Union
 
 import click
-import requests
 
 import sky
 from sky import sky_logging
+from sky.adaptors import common as adaptors_common
 from sky.usage import constants
 from sky.utils import common_utils
 from sky.utils import env_options
 from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
+    import inspect
+
+    import requests
+
     from sky import resources as resources_lib
     from sky import status_lib
     from sky import task as task_lib
+else:
+    # requests and inspect cost ~100ms to load, which can be postponed to
+    # collection phase or skipped if user specifies no collection
+    requests = adaptors_common.LazyImport('requests')
+    inspect = adaptors_common.LazyImport('inspect')
 
 logger = sky_logging.init_logger(__name__)
 

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/utils/accelerator_registry.py

@@ -3,6 +3,7 @@ import typing
 from typing import Optional
 
 from sky.clouds import service_catalog
+from sky.utils import rich_utils
 from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
@@ -88,14 +89,17 @@ def canonicalize_accelerator_name(accelerator: str,
     if accelerator.lower() in mapping:
         return mapping[accelerator.lower()]
 
-    # _ACCELERATORS may not be comprehensive.
-    # Users may manually add new accelerators to the catalogs, or download new
-    # catalogs (that have new accelerators) without upgrading SkyPilot.
-    # To cover such cases, we should search the accelerator name
-    # in the service catalog.
-    searched = service_catalog.list_accelerators(name_filter=accelerator,
-                                                 case_sensitive=False,
-                                                 clouds=cloud_str)
+    # Listing accelerators can be time-consuming since canonicalizing usually
+    # involves catalog reading with cache not warmed up.
+    with rich_utils.safe_status('Listing accelerators...'):
+        # _ACCELERATORS may not be comprehensive.
+        # Users may manually add new accelerators to the catalogs, or download
+        # new catalogs (that have new accelerators) without upgrading SkyPilot.
+        # To cover such cases, we should search the accelerator name
+        # in the service catalog.
+        searched = service_catalog.list_accelerators(name_filter=accelerator,
+                                                     case_sensitive=False,
+                                                     clouds=cloud_str)
     names = list(searched.keys())
 
     # Exact match.

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/utils/db_utils.py

@@ -4,11 +4,27 @@ import sqlite3
 import threading
 from typing import Any, Callable, Optional
 
+# This parameter (passed to sqlite3.connect) controls how long we will wait to
+# obtains a database lock (not necessarily during connection, but whenever it is
+# needed). It is not a connection timeout.
+# Even in WAL mode, only a single writer is allowed at a time. Other writers
+# will block until the write lock can be obtained. This behavior is described in
+# the SQLite documentation for WAL: https://www.sqlite.org/wal.html
+# Python's default timeout is 5s. In normal usage, lock contention is very low,
+# and this is more than sufficient. However, in some highly concurrent cases,
+# such as a jobs controller suddenly recovering thousands of jobs at once, we
+# can see a small number of processes that take much longer to obtain the lock.
+# In contrived highly contentious cases, around 0.1% of transactions will take
+# >30s to take the lock. We have not seen cases that take >60s. For cases up to
+# 1000x parallelism, this is thus thought to be a conservative setting.
+# For more info, see the PR description for #4552.
+_DB_TIMEOUT_S = 60
+
 
 @contextlib.contextmanager
 def safe_cursor(db_path: str):
     """A newly created, auto-committing, auto-closing cursor."""
-    conn = sqlite3.connect(db_path)
+    conn = sqlite3.connect(db_path, timeout=_DB_TIMEOUT_S)
     cursor = conn.cursor()
     try:
         yield cursor
@@ -79,8 +95,6 @@ class SQLiteConn(threading.local):
     def __init__(self, db_path: str, create_table: Callable):
         super().__init__()
         self.db_path = db_path
-        # NOTE: We use a timeout of 10 seconds to avoid database locked
-        # errors. This is a hack, but it works.
-        self.conn = sqlite3.connect(db_path, timeout=10)
+        self.conn = sqlite3.connect(db_path, timeout=_DB_TIMEOUT_S)
         self.cursor = self.conn.cursor()
         create_table(self.cursor, self.conn)

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/utils/log_utils.py

@@ -5,6 +5,8 @@ import types
 from typing import Callable, Iterator, List, Optional, TextIO, Type
 
 import colorama
+# slow due to https://github.com/python-pendulum/pendulum/issues/808
+# FIXME(aylei): bump pendulum if it get fixed
 import pendulum
 import prettytable
 

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115}/sky/utils/subprocess_utils.py

@@ -5,7 +5,7 @@ import random
 import resource
 import subprocess
 import time
-from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import colorama
 import psutil
@@ -97,7 +97,7 @@ def get_parallel_threads(cloud_str: Optional[str] = None) -> int:
 
 
 def run_in_parallel(func: Callable,
-                    args: Iterable[Any],
+                    args: List[Any],
                     num_threads: Optional[int] = None) -> List[Any]:
     """Run a function in parallel on a list of arguments.
 
@@ -113,6 +113,11 @@ def run_in_parallel(func: Callable,
       A list of the return values of the function func, in the same order as the
       arguments.
     """
+    if len(args) == 0:
+        return []
+    # Short-circuit for single element
+    if len(args) == 1:
+        return [func(args[0])]
     # Reference: https://stackoverflow.com/questions/25790279/python-multiprocessing-early-termination # pylint: disable=line-too-long
     processes = num_threads if num_threads is not None else get_parallel_threads(
     )

{skypilot_nightly-1.0.0.dev20250113 → skypilot_nightly-1.0.0.dev20250115/skypilot_nightly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: skypilot-nightly
-Version: 1.0.0.dev20250113
+Version: 1.0.0.dev20250115
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0
@@ -351,6 +351,8 @@ Read the research:
 - [Sky Computing vision paper](https://sigops.org/s/conferences/hotos/2021/papers/hotos21-s02-stoica.pdf) (HotOS 2021)
 - [Policy for Managed Spot Jobs](https://www.usenix.org/conference/nsdi24/presentation/wu-zhanghao)  (NSDI 2024)
 
+SkyPilot was initially started at the [Sky Computing Lab](https://sky.cs.berkeley.edu) at UC Berkeley and has since gained many industry contributors. Read more about the project's origin [here](https://docs.skypilot.co/en/latest/sky-computing.html).
+
 ## Support and Questions
 We are excited to hear your feedback!
 * For issues and feature requests, please [open a GitHub issue](https://github.com/skypilot-org/skypilot/issues/new).