Performance related modifications (#162)

* Avoid copying similarity distance matrix locally inside functions

* Change all copy and explicit modify operations by in-place modify in adaptivity

* Fix tests

* Fix tests

* Formatting and adding Changelog entry

* Compare float32 against a float32

* Add custom event to global adaptivity

* Add custom profiling section to local adaptivity, and fix tests

* Add a configurable option to output memory usage in every time window

* Add psutil as a dependency

* Calculate maximum similarity distance only once

* Fix serial adaptivity test

* Add a note of data type restriction to the collected global data for global adaptivity

Author: IshaanDesai

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## latest
 
+- Performance improvements: restricting data types, in-place modifications https://github.com/precice/micro-manager/pull/162
 - Handle adaptivity case when deactivation and activation happens in the same time window https://github.com/precice/micro-manager/pull/165
 - Add command line input argument to set log file https://github.com/precice/micro-manager/pull/163
 - Fix adaptivity metrics logging and add logging documentation https://github.com/precice/micro-manager/pull/160

micro_manager/adaptivity/adaptivity.py

@@ -12,7 +12,7 @@
 
 
 class AdaptivityCalculator:
-    def __init__(self, configurator, rank) -> None:
+    def __init__(self, configurator, rank, nsims) -> None:
         """
         Class constructor.
 
@@ -22,6 +22,8 @@ def __init__(self, configurator, rank) -> None:
             Object which has getter functions to get parameters defined in the configuration file.
         rank : int
             Rank of the MPI communicator.
+        nsims : int
+            Number of micro simulations.
         """
         self._refine_const = configurator.get_adaptivity_refining_const()
         self._coarse_const = configurator.get_adaptivity_coarsening_const()
@@ -36,6 +38,23 @@ def __init__(self, configurator, rank) -> None:
 
         self._rank = rank
 
+        # similarity_dists: 2D array having similarity distances between each micro simulation pair
+        # This matrix is modified in place via the function update_similarity_dists
+        # NOTE: Data type restricted to float32 to save memory. Remove this restriction if higher precision is needed.
+        self._similarity_dists = np.zeros((nsims, nsims), dtype=np.float32)
+
+        self._max_similarity_dist = 0.0
+
+        # is_sim_active: 1D array having state (active or inactive) of each micro simulation
+        # Start adaptivity calculation with all sims active
+        # This array is modified in place via the function update_active_sims and update_inactive_sims
+        self._is_sim_active = np.array([True] * nsims, dtype=np.bool_)
+
+        # sim_is_associated_to: 1D array with values of associated simulations of inactive simulations. Active simulations have None
+        # Active sims do not have an associated sim
+        # This array is modified in place via the function associate_inactive_to_active
+        self._sim_is_associated_to = np.full((nsims), -2, dtype=np.intc)
+
         self._just_deactivated: list[int] = []
 
         self._similarity_measure = self._get_similarity_measure(
@@ -69,29 +88,19 @@ def __init__(self, configurator, rank) -> None:
             csv_logger=True,
         )
 
-    def _get_similarity_dists(
-        self, dt: float, similarity_dists: np.ndarray, data: dict
-    ) -> np.ndarray:
+    def _update_similarity_dists(self, dt: float, data: dict) -> None:
         """
         Calculate metric which determines if two micro simulations are similar enough to have one of them deactivated.
 
         Parameters
         ----------
         dt : float
             Current time step
-        similarity_dists : numpy array
-            2D array having similarity distances between each micro simulation pair
         data : dict
             Data to be used in similarity distance calculation
-
-        Returns
-        -------
-        similarity_dists : numpy array
-            Updated 2D array having similarity distances between each micro simulation pair
         """
-        _similarity_dists = np.copy(similarity_dists)
+        self._similarity_dists = exp(-self._hist_param * dt) * self._similarity_dists
 
-        data_diff = np.zeros_like(_similarity_dists)
         for name in data.keys():
             data_vals = np.array(data[name])
             if data_vals.ndim == 1:
@@ -100,97 +109,56 @@ def _get_similarity_dists(
                 # The axis is later reduced with a norm.
                 data_vals = np.expand_dims(data_vals, axis=1)
 
-            data_diff += self._similarity_measure(data_vals)
+            self._similarity_dists += dt * self._similarity_measure(data_vals)
 
-        return exp(-self._hist_param * dt) * _similarity_dists + dt * data_diff
+        self._max_similarity_dist = np.amax(self._similarity_dists)
 
-    def _update_active_sims(
-        self, similarity_dists: np.ndarray, is_sim_active: np.ndarray
-    ) -> np.ndarray:
+    def _update_active_sims(self) -> None:
         """
         Update set of active micro simulations. Active micro simulations are compared to each other
         and if found similar, one of them is deactivated.
-
-        Parameters
-        ----------
-        similarity_dists : numpy array
-            2D array having similarity distances between each micro simulation pair
-        is_sim_active : numpy array
-            1D array having state (active or inactive) of each micro simulation
-
-        Returns
-        -------
-        _is_sim_active : numpy array
-            Updated 1D array having state (active or inactive) of each micro simulation
         """
-        max_similarity_dist = np.amax(similarity_dists)
-
-        if max_similarity_dist == 0.0:
+        if self._max_similarity_dist == 0.0:
             warn(
                 "All similarity distances are zero, probably because all the data for adaptivity is the same. Coarsening tolerance will be manually set to minimum float number."
             )
             self._coarse_tol = sys.float_info.min
         else:
             self._coarse_tol = (
-                self._coarse_const * self._refine_const * max_similarity_dist
+                self._coarse_const * self._refine_const * self._max_similarity_dist
             )
 
-        _is_sim_active = np.copy(
-            is_sim_active
-        )  # Input is_sim_active is not longer used after this point
-
         # Update the set of active micro sims
-        for i in range(_is_sim_active.size):
-            if _is_sim_active[i]:  # if sim is active
-                if self._check_for_deactivation(i, similarity_dists, _is_sim_active):
-                    _is_sim_active[i] = False
+        for i in range(self._is_sim_active.size):
+            if self._is_sim_active[i]:  # if sim is active
+                if self._check_for_deactivation(i, self._is_sim_active):
+                    self._is_sim_active[i] = False
                     self._just_deactivated.append(i)
 
-        return _is_sim_active
-
-    def _associate_inactive_to_active(
-        self,
-        similarity_dists: np.ndarray,
-        is_sim_active: np.ndarray,
-        sim_is_associated_to: np.ndarray,
-    ) -> np.ndarray:
+    def _associate_inactive_to_active(self) -> None:
         """
         Associate inactive micro simulations to most similar active micro simulation.
-
-        Parameters
-        ----------
-        similarity_dists : numpy array
-            2D array having similarity distances between each micro simulation pair
-        is_sim_active : numpy array
-            1D array having state (active or inactive) of each micro simulation
-        sim_is_associated_to : numpy array
-            1D array with values of associated simulations of inactive simulations. Active simulations have None
-
-        Returns
-        -------
-        _sim_is_associated_to : numpy array
-            1D array with values of associated simulations of inactive simulations. Active simulations have None
         """
-        active_ids = np.where(is_sim_active)[0]
-        inactive_ids = np.where(is_sim_active == False)[0]
+        active_ids = np.where(self._is_sim_active)[0]
+        inactive_ids = np.where(self._is_sim_active == False)[0]
 
-        _sim_is_associated_to = np.copy(sim_is_associated_to)
+        # Start with a large distance to trigger the search for the most similar active sim
+        dist_min_start_value = 2 * self._max_similarity_dist
 
         # Associate inactive micro sims to active micro sims
         for inactive_id in inactive_ids:
-            dist_min = sys.float_info.max
+            # Begin with a large distance to trigger the search for the most similar active sim
+            dist_min = dist_min_start_value
             for active_id in active_ids:
                 # Find most similar active sim for every inactive sim
-                if similarity_dists[inactive_id, active_id] < dist_min:
+                if self._similarity_dists[inactive_id, active_id] < dist_min:
                     associated_active_id = active_id
-                    dist_min = similarity_dists[inactive_id, active_id]
-
-            _sim_is_associated_to[inactive_id] = associated_active_id
+                    dist_min = self._similarity_dists[inactive_id, active_id]
 
-        return _sim_is_associated_to
+            self._sim_is_associated_to[inactive_id] = associated_active_id
 
     def _check_for_activation(
-        self, inactive_id: int, similarity_dists: np.ndarray, is_sim_active: np.ndarray
+        self, inactive_id: int, is_sim_active: np.ndarray
     ) -> bool:
         """
         Check if an inactive simulation needs to be activated.
@@ -199,8 +167,6 @@ def _check_for_activation(
         ----------
         inactive_id : int
             ID of inactive simulation which is checked for activation.
-        similarity_dists : numpy array
-            2D array having similarity distances between each micro simulation pair.
         is_sim_active : numpy array
             1D array having state (active or inactive) of each micro simulation.
 
@@ -211,13 +177,13 @@ def _check_for_activation(
         """
         active_sim_ids = np.where(is_sim_active)[0]
 
-        dists = similarity_dists[inactive_id, active_sim_ids]
+        dists = self._similarity_dists[inactive_id, active_sim_ids]
 
         # If inactive sim is not similar to any active sim, activate it
         return min(dists) > self._ref_tol
 
     def _check_for_deactivation(
-        self, active_id: int, similarity_dists: np.ndarray, is_sim_active: np.ndarray
+        self, active_id: int, is_sim_active: np.ndarray
     ) -> bool:
         """
         Check if an active simulation needs to be deactivated.
@@ -226,8 +192,6 @@ def _check_for_deactivation(
         ----------
         active_id : int
             ID of active simulation which is checked for deactivation.
-        similarity_dists : numpy array
-            2D array having similarity distances between each micro simulation pair.
         is_sim_active : numpy array
             1D array having state (active or inactive) of each micro simulation.
 
@@ -241,7 +205,7 @@ def _check_for_deactivation(
         for active_id_2 in active_sim_ids:
             if active_id != active_id_2:  # don't compare active sim to itself
                 # If active sim is similar to another active sim, deactivate it
-                if similarity_dists[active_id, active_id_2] < self._coarse_tol:
+                if self._similarity_dists[active_id, active_id_2] < self._coarse_tol:
                     return True
         return False