Repository: microsoft/vasim (language: python)

Issue:
remove granularity
We have some leftover code related to `granularity` that we used for the [CaaSPER](https://www.microsoft.com/en-us/research/publication/caasper-vertical-autoscaling/) algorithm-1 but don't want to bake-in here!


Discussion / hints:

Fix patch:
diff --git a/examples/data/metadata.json b/examples/data/metadata.json
index 38e4826..4017c18 100644
--- a/examples/data/metadata.json
+++ b/examples/data/metadata.json
@@ -6,8 +6,7 @@
         "window": 20,
         "lag": 10,
         "max_cpu_limit": 25,
-        "min_cpu_limit": 2.0,
-        "granularity": 1
+        "min_cpu_limit": 2.0
     },
     "prediction_config": {
         "waiting_before_predict": 1440,
diff --git a/examples/using_vasim.ipynb b/examples/using_vasim.ipynb
index 464d331..d10c20c 100644
--- a/examples/using_vasim.ipynb
+++ b/examples/using_vasim.ipynb
@@ -177,7 +177,6 @@
     "  * `min_cpu_limit` (int): The minimum number of cores to recommend. This is used as a [safety guard](https://github.com/microsoft/vasim/blob/198a06062a91f6455b87710b0e59834530b6ea29/simulator/SimulatedInfraScaler.py#L56) in the simulated infra.\n",
     "  * `max_cpu_limit` (int): The maximum number of cores to recommend. (same as min)\n",
     "  * `recovery_time` (int of minutes, optional, default is 15): The **minimum** amount of time in minutes to wait before making another scaling decision.\n",
-    "  * `granularity` (int, unused): This needs to be removed [#35](https://github.com/microsoft/vasim/issues/35), but for now it must be an integer.\n",
     "* **`prediction_config`** : this relates to the window of [predicted](https://github.com/microsoft/vasim/blob/198a06062a91f6455b87710b0e59834530b6ea29/recommender/cluster_state_provider/PredictiveFileClusterStateProvider.py#L29) data that is fed into the algorithm. It uses a time series to forecast what the data might be in the future to help the algorithm proactively scale\n",
     "  * `waiting_before_predict` (int of minutes) : This is the amount of data to consume before making prediction. It is usually set to `1440`, for 60 min * 24 hours = 1 day. In general, it is waiting for one full cycle of data (`period` in the graph below) to pass. Sometimes this is daily, sometimes weekly, etc.  TODO: autodetermine this.\n",
     "  * `frequency_minutes` (int) : This is how frequent your timestamps are in the csvs you provide. This *MUST* match your csvs.  (Ex: 1 in the above case.) TODO: automate.\n",
@@ -218,8 +217,7 @@
       "        \"window\": 20,\n",
       "        \"lag\": 10,\n",
       "        \"max_cpu_limit\": 25,\n",
-      "        \"min_cpu_limit\": 2.0,\n",
-      "        \"granularity\": 1\n",
+      "        \"min_cpu_limit\": 2.0\n",
       "    },\n",
       "    \"prediction_config\": {\n",
       "        \"waiting_before_predict\": 1440,\n",
@@ -309,16 +307,16 @@
       "Prediction config was detected:{'waiting_before_predict': 1440, 'frequency_minutes': 1, 'minutes_to_predict': 10, 'forecasting_models': 'naive', 'total_predictive_window': 30}\n",
       "config: {}\n",
       "logger: <RootLogger root (ERROR)>\n",
-      "data_dir: /home/bpkroth/src/ozone/vasim/examples/data\n",
+      "data_dir: /datadrive/vasim/examples/data\n",
       "features: ['cpu']\n",
-      "decision_file_path: /home/bpkroth/src/ozone/vasim/examples/data/_simulations/target_cfg-235b7b95-72c4/decisions.txt\n",
+      "decision_file_path: /datadrive/vasim/examples/data/_simulations/target_cfg-9f391f17-c004/decisions.txt\n",
       "save_metadata: True\n",
       "frequency_minutes: 1\n",
       "minutes_to_predict: 10\n",
       "freq: 1T\n",
       "waiting_time: 1440\n",
-      "data_processor: <vasim.recommender.forecasting.utils.DataProcessor.DataProcessor object at 0x7f2e64378370>\n",
-      "data_forecaster: <vasim.recommender.forecasting.TimeSeriesForecaster.TimeSeriesForecaster object at 0x7f2e64378310>\n",
+      "data_processor: <vasim.recommender.forecasting.utils.DataProcessor.DataProcessor object at 0x7cf12515f730>\n",
+      "data_forecaster: <vasim.recommender.forecasting.TimeSeriesForecaster.TimeSeriesForecaster object at 0x7cf12515f6d0>\n",
       "cores: 0\n",
       "predicted_cores: 0\n",
       "_prediction_activated: False\n",
@@ -518,13 +516,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "total 24\n",
-      "drwxr-xr-x 2 bpkroth bpkroth 4096 Sep 17 13:09 target_cfg-08f1d1f7-9c94\n",
-      "drwxr-xr-x 2 bpkroth bpkroth 4096 Sep 17 13:09 target_cfg-244a0313-ff74\n",
-      "drwxr-xr-x 2 bpkroth bpkroth 4096 Sep 17 13:09 target_cfg-5d99567a-6a44\n",
-      "drwxr-xr-x 2 bpkroth bpkroth 4096 Sep 17 13:09 target_cfg-85ff26f9-59e4\n",
-      "drwxr-xr-x 2 bpkroth bpkroth 4096 Sep 17 13:09 target_cfg-d8275fe1-fb04\n",
-      "drwxr-xr-x 2 bpkroth bpkroth 4096 Sep 17 13:09 target_cfg-eb864cf6-96d4\n"
+      "total 0\n",
+      "drwxrwxr-x 2 apavlenko apavlenko 178 Sep 17 21:17 target_cfg-4a8eb73e-7124\n",
+      "drwxrwxr-x 2 apavlenko apavlenko 178 Sep 17 21:17 target_cfg-866b8d32-d5e4\n",
+      "drwxrwxr-x 2 apavlenko apavlenko 178 Sep 17 21:17 target_cfg-9cb43ac6-3424\n",
+      "drwxrwxr-x 2 apavlenko apavlenko 178 Sep 17 21:17 target_cfg-9cf87c6c-5a24\n",
+      "drwxrwxr-x 2 apavlenko apavlenko 178 Sep 17 21:17 target_cfg-e80f8023-e1b4\n",
+      "drwxrwxr-x 2 apavlenko apavlenko 178 Sep 17 21:17 target_cfg-f4728edd-eeb4\n"
      ]
     }
    ],
@@ -566,7 +564,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<IPython.core.display.Image object>"
       ]
@@ -603,11 +601,11 @@
      "output_type": "stream",
      "text": [
       "Closest combination to (0, 0) is dimension_1: 19487.21896972081, dimension_2: 289.95169699353437\n",
-      "Folder: target_cfg-08f1d1f7-9c94, Config: {}\n",
-      "Folder: target_cfg-08f1d1f7-9c94\n",
+      "Folder: target_cfg-4a8eb73e-7124, Config: {}\n",
+      "Folder: target_cfg-4a8eb73e-7124\n",
       "All Configs:\n",
       "algo_specific_config: {'addend': 1}\n",
-      "general_config: {'window': 60, 'lag': 10, 'max_cpu_limit': 25, 'min_cpu_limit': 2.0, 'granularity': 1}\n",
+      "general_config: {'window': 60, 'lag': 10, 'max_cpu_limit': 25, 'min_cpu_limit': 2.0}\n",
       "predictive_config: None\n",
       "Slack: 19487.21896972081\n",
       "Insufficient CPU: 289.95169699353437\n"
diff --git a/src/vasim/recommender/cluster_state_provider/FileClusterStateProvider.py b/src/vasim/recommender/cluster_state_provider/FileClusterStateProvider.py
index 3a48556..1c3368e 100644
--- a/src/vasim/recommender/cluster_state_provider/FileClusterStateProvider.py
+++ b/src/vasim/recommender/cluster_state_provider/FileClusterStateProvider.py
@@ -30,7 +30,7 @@ class FileClusterStateProvider(ClusterStateProvider):
     """
 
     def __init__(self, data_dir=None, features=["cpu"], window=40, decision_file_path=None, lag=5.0,
-                 granularity=1, min_cpu_limit=1, max_cpu_limit=None, save_metadata=True, **kwargs):
+                 min_cpu_limit=1, max_cpu_limit=None, save_metadata=True, **kwargs):
         """
         Parameters:
             data_dir (str): The directory where the csvs are stored.
@@ -38,7 +38,6 @@ def __init__(self, data_dir=None, features=["cpu"], window=40, decision_file_pat
             window (int): Window in minutes to capture VALID data in order to evaluate PP curve
             decision_file_path (str): The path to the file where Doppler will write decisions
             lag (float): Number of minutes to wait after making a decision
-            granularity (int): Granularity desired for the price-performance curve, formerly "coredelta"
             min_cpu_limit (int): The minimum number of cores to recommend (When set to None it assumes 1)
             max_cpu_limit (int): The maximum number of cores to recommend. (When set to None, it assumes max on the machine)
             save_metadata (bool): Whether to save metadata to a file in the data_dir
@@ -187,18 +186,6 @@ def truncate_data(self, recorded_data, last_decision_time):
         recorded_data = recorded_data[recorded_data["time"] <= end_time]
         return recorded_data, end_time
 
-    def create_resource_limits(self):
-        # Infact I think we need to remove most of this file, as it won't be used in the simulator.
-        vcpus_increments = self.config.general_config['max_cpu_limit'] * self.config.general_config['granularity'] + 1
-        new_resource_limits = pd.DataFrame(
-            data={"cpu": np.linspace(0, self.config.general_config['max_cpu_limit'], num=vcpus_increments)})
-        new_resource_limits[
-            "new_price"] = new_resource_limits["cpu"]  # we removed price from the model
-        # TODO: where is this used?
-        new_resource_limits["sku"] = new_resource_limits["cpu"].apply(
-            lambda x: str(round(x, 2)) + "vcpu")
-        return new_resource_limits
-
     def get_last_decision_time(self, recorded_data):
         # Check if the decisions file exists
         if not os.path.exists(self.decision_file_path):
diff --git a/src/vasim/simulator/SimulatedBaseClusterStateProvider.py b/src/vasim/simulator/SimulatedBaseClusterStateProvider.py
index 2bbc0d3..b3336bc 100644
--- a/src/vasim/simulator/SimulatedBaseClusterStateProvider.py
+++ b/src/vasim/simulator/SimulatedBaseClusterStateProvider.py
@@ -16,7 +16,7 @@
 class SimulatedBaseClusterStateProvider(ClusterStateProvider):
     # TODO: I am not sure if this class is used? it is not tested if so.
     def __init__(self, data_dir="data/performance_log", window=40, decision_file_path=None,
-                 max_cpu_limit=None, granularity=None, lag=None, **kwargs):
+                 max_cpu_limit=None, lag=None, **kwargs):
 
         self.logger = logging.getLogger()
         self.logger.info("SimulatedBaseClusterStateProvider init")
@@ -28,7 +28,6 @@ def __init__(self, data_dir="data/performance_log", window=40, decision_file_pat
         self.config = kwargs.get("config")
         # TODO: these did not get updated to the new config format
         self.max_cpu_limit = max_cpu_limit
-        self.granularity = granularity
         self.lag = lag
         self.window = window
 
diff --git a/src/vasim/simulator/SimulatedClusterStateProviderFactory.py b/src/vasim/simulator/SimulatedClusterStateProviderFactory.py
index 901a8a2..6e6f514 100644
--- a/src/vasim/simulator/SimulatedClusterStateProviderFactory.py
+++ b/src/vasim/simulator/SimulatedClusterStateProviderFactory.py
@@ -27,7 +27,6 @@ def create_provider(self, predictive: bool) -> SimulatedBaseClusterStateProvider
                 prediction_config=self.prediction_config,
                 max_cpu_limit=self.config.general_config['max_cpu_limit'],
                 decision_file_path=self.out_filename,
-                granularity=self.config.general_config['granularity'],
                 lag=self.config.general_config['lag'],
                 window=self.config.general_config['window'],
                 min_cpu_limit=self.config.general_config['min_cpu_limit'],
@@ -38,7 +37,6 @@ def create_provider(self, predictive: bool) -> SimulatedBaseClusterStateProvider
                 data_dir=self.data_dir,
                 max_cpu_limit=self.config.general_config['max_cpu_limit'],
                 decision_file_path=self.out_filename,
-                granularity=self.config.general_config['granularity'],
                 lag=self.config.general_config['lag'],
                 window=self.config.general_config['window'],
                 min_cpu_limit=self.config.general_config['min_cpu_limit'],
diff --git a/src/vasim/simulator/SimulatedInMemoryClusterStateProvider.py b/src/vasim/simulator/SimulatedInMemoryClusterStateProvider.py
index 4a437f3..a938938 100644
--- a/src/vasim/simulator/SimulatedInMemoryClusterStateProvider.py
+++ b/src/vasim/simulator/SimulatedInMemoryClusterStateProvider.py
@@ -15,12 +15,12 @@
 
 class SimulatedInMemoryClusterStateProvider(SimulatedBaseClusterStateProvider, FileClusterStateProvider):
     def __init__(self, data_dir="data/performance_log", window=40, decision_file_path=None,
-                 max_cpu_limit=None, granularity=None, lag=None, **kwargs):
+                 max_cpu_limit=None, lag=None, **kwargs):
 
         FileClusterStateProvider.__init__(self, data_dir=data_dir, window=window,
-                                          decision_file_path=decision_file_path, granularity=granularity, max_cpu_limit=max_cpu_limit, lag=lag, **kwargs)
+                                          decision_file_path=decision_file_path, max_cpu_limit=max_cpu_limit, lag=lag, **kwargs)
         SimulatedBaseClusterStateProvider.__init__(
-            self, data_dir=data_dir, window=window, decision_file_path=decision_file_path, granularity=granularity, max_cpu_limit=max_cpu_limit, lag=lag, **kwargs)
+            self, data_dir=data_dir, window=window, decision_file_path=decision_file_path, max_cpu_limit=max_cpu_limit, lag=lag, **kwargs)
 
 # we read updated file every time
 
diff --git a/src/vasim/simulator/SimulatedInMemoryPredictiveClusterStateProvider.py b/src/vasim/simulator/SimulatedInMemoryPredictiveClusterStateProvider.py
index 2a717ce..ff583ab 100644
--- a/src/vasim/simulator/SimulatedInMemoryPredictiveClusterStateProvider.py
+++ b/src/vasim/simulator/SimulatedInMemoryPredictiveClusterStateProvider.py
@@ -16,11 +16,11 @@
 
 class SimulatedInMemoryPredictiveClusterStateProvider(SimulatedBaseClusterStateProvider, PredictiveFileClusterStateProvider):
     def __init__(self, data_dir="data/performance_log", window=40, decision_file_path=None,
-                 max_cpu_limit=None, granularity=None, lag=None, **kwargs):
+                 max_cpu_limit=None, lag=None, **kwargs):
         PredictiveFileClusterStateProvider.__init__(
-            self, data_dir=data_dir, window=window, decision_file_path=decision_file_path, granularity=granularity, max_cpu_limit=max_cpu_limit, lag=lag, **kwargs)
+            self, data_dir=data_dir, window=window, decision_file_path=decision_file_path, max_cpu_limit=max_cpu_limit, lag=lag, **kwargs)
         SimulatedBaseClusterStateProvider.__init__(
-            self, data_dir=data_dir, window=window, decision_file_path=decision_file_path, granularity=granularity, max_cpu_limit=max_cpu_limit, lag=lag, **kwargs)
+            self, data_dir=data_dir, window=window, decision_file_path=decision_file_path, max_cpu_limit=max_cpu_limit, lag=lag, **kwargs)
 
     # we read updated file every time
     def read_metrics_data(self):


Test patch:
diff --git a/tests/test_data/alibaba_control_c_29247_denom_1/metadata.json b/tests/test_data/alibaba_control_c_29247_denom_1/metadata.json
index 16c4075..c7eee61 100644
--- a/tests/test_data/alibaba_control_c_29247_denom_1/metadata.json
+++ b/tests/test_data/alibaba_control_c_29247_denom_1/metadata.json
@@ -6,7 +6,6 @@
     "general_config": {
         "window": 20,
         "lag": 10,
-        "granularity": 1,
         "max_cpu_limit": 25,
         "min_cpu_limit": 2.0
     },
diff --git a/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata.json b/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata.json
index b51d3cd..5e2afc5 100644
--- a/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata.json
+++ b/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata.json
@@ -5,7 +5,6 @@
     "general_config": {
         "window": 20,
         "lag": 10,
-        "granularity": 1,
         "max_cpu_limit": 25,
         "min_cpu_limit": 2.0
     },
diff --git a/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata_alt_config.json b/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata_alt_config.json
index 8f6572c..cc5b079 100644
--- a/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata_alt_config.json
+++ b/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata_alt_config.json
@@ -6,7 +6,6 @@
         "recovery_time": 5,
         "window": 20,
         "lag": 10,
-        "granularity": 1,
         "max_cpu_limit": 25,
         "min_cpu_limit": 2.0
     },
diff --git a/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata_alt_config_lag.json b/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata_alt_config_lag.json
index fd3cd25..ef966f2 100644
--- a/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata_alt_config_lag.json
+++ b/tests/test_data/alibaba_control_c_29247_denom_1_mini/metadata_alt_config_lag.json
@@ -6,7 +6,6 @@
         "lag": 5,
         "recovery_time": 5,
         "window": 20,
-        "granularity": 1,
         "max_cpu_limit": 25,
         "min_cpu_limit": 2.0
     },
diff --git a/tests/test_data/alibaba_control_c_29247_denom_1_toosmall/metadata.json b/tests/test_data/alibaba_control_c_29247_denom_1_toosmall/metadata.json
index b51d3cd..5e2afc5 100644
--- a/tests/test_data/alibaba_control_c_29247_denom_1_toosmall/metadata.json
+++ b/tests/test_data/alibaba_control_c_29247_denom_1_toosmall/metadata.json
@@ -5,7 +5,6 @@
     "general_config": {
         "window": 20,
         "lag": 10,
-        "granularity": 1,
         "max_cpu_limit": 25,
         "min_cpu_limit": 2.0
     },
diff --git a/tests/test_metrics_data_window.py b/tests/test_metrics_data_window.py
index add7001..a7c2ecc 100644
--- a/tests/test_metrics_data_window.py
+++ b/tests/test_metrics_data_window.py
@@ -50,7 +50,7 @@ def test_read_metrics_data(self):
 
         sim_inmem_p_prov = SimulatedInMemoryPredictiveClusterStateProvider(window=40, lag=10, data_dir=self.target_dir,
                                                                            decision_file_path=self.target_dir / "decisions.txt",
-                                                                           max_cpu_limit=14, granularity=1, config=self.config,
+                                                                           max_cpu_limit=14, config=self.config,
                                                                            prediction_config=self.config.prediction_config,
                                                                            general_config=self.config.general_config)
 
@@ -98,7 +98,7 @@ def test_get_next_recorded_data(self):
 
         file_cs_prov = FileClusterStateProvider(window=40, lag=10, data_dir=self.target_dir,
                                                 decision_file_path=self.target_dir / "decisions.txt",
-                                                max_cpu_limit=14, granularity=1, config=self.config,
+                                                max_cpu_limit=14, config=self.config,
                                                 prediction_config=self.config.prediction_config,
                                                 general_config=self.config.general_config)