#586: finally fixed bug in bounds

Author: ppebay

config/synthetic-blocks.yaml

@@ -14,7 +14,7 @@ work_model:
     gamma: 0.0
     delta: 0.0
     upper_bounds:
-      max_memory_usage: 27.0
+      max_memory_usage: 36.0
 
 # Specify algorithm
 algorithm:

src/lbaf/Execution/lbsClusteringTransferStrategy.py

@@ -182,6 +182,10 @@ def __swap_clusters(self, phase: Phase, r_src: Rank, clusters_src:dict, targets:
             for k_src, o_src in clusters_src.items():
                 # Iterate over target clusters
                 for k_try, o_try in clusters_try.items():
+                    # Skip trivial case
+                    if not o_src and not o_try:
+                        continue
+
                     # Decide whether swap is beneficial
                     c_try = self._criterion.compute(r_src, o_src, r_try, o_try)
                     self.__n_swap_tries += 1

src/lbaf/Execution/lbsTemperedCriterion.py

@@ -68,8 +68,8 @@ def compute(self, r_src: Rank, o_src: list, r_dst: Rank, o_dst: Optional[list]=N
 
         # Compute update formulae
         w_max_new = max(
-            self._work_model.update(r_src, o_src, o_dst),
-            self._work_model.update(r_dst, o_dst, o_src))
+            self._work_model.update(r_src, r_dst, o_src, o_dst),
+            self._work_model.update(r_dst, r_src, o_dst, o_src))
 
         # Report computed values in debug mode
         self._logger.debug(f"Arrangement work; original: {w_max_0}; updated: {w_max_new}")

src/lbaf/Model/lbsAffineCombinationWorkModel.py

@@ -111,6 +111,39 @@ def compute(self, rank: Rank):
             rank.get_sent_volume(),
             rank.get_homing())
 
+    def __update_bounds(self, r_snd: Rank, r_rcv: Rank, o_snd: list, o_rcv: list):
+        """Update verification of bounds if objects are to be sent and received."""
+        # Distinguish between upper bound QOIs
+        for k, v in self.__upper_bounds.items():
+            if k == "max_memory_usage":
+                # Initialize post-transfer set of objects
+                o_new = set()
+
+                # Node-level upper bound
+                if self.__node_bounds:
+                    n_snd = r_snd.get_node()
+                    o_new = n_snd.get_objects()
+                    # Updated objects only if transfer is not node-local
+                    if n_snd != r_rcv.get_node():
+                        o_new = (o_new.difference(o_snd)).union(o_rcv)
+
+                # Rank-level upper bound
+                else:
+                    o_new = (r_snd.get_objects().difference(o_snd)).union(o_rcv)
+
+                # Compute new set of blocks and check upper bound
+                b_new = set(o.get_shared_block() for o in o_new if o.get_shared_block())
+                return b_new and (sum(b.get_size() for b in b_new) > v)
+
+            else:
+                # Ignore unsupported upper bound types
+                self.__logger.warning(
+                    f"Upper bound update formula not supported for {k}, ignoring it.")
+                return False
+
+        # Bounds are satisfied by default
+        return False
+
     def __update_load(self, rank: Rank, o_snd: list, o_rcv: list):
         """Update total load if objects are to be sent and received."""
         return rank.get_load() - sum(
@@ -271,12 +304,16 @@ def __update_homing(self, rank: Rank, o_snd: list, o_rcv: list):
         # Return updated homing cost
         return homing
 
-    def update(self, rank: Rank, o_snd: list, o_rcv: list):
+    def update(self, r_snd: Rank, r_rcv: Rank, o_snd: list, o_rcv: list):
         """Update work if objects are to be sent and received."""
+        # Check whether strict bounds are satisfied
+        if self.__update_bounds(r_snd, r_rcv, o_snd, o_rcv):
+                return math.inf
+
         # Return combination of load and volumes
         return self.affine_combination(
-            rank.get_alpha(),
-            self.__update_load(rank, o_snd, o_rcv),
-            self.__update_received(rank, o_snd, o_rcv),
-            self.__update_sent(rank, o_snd, o_rcv),
-            self.__update_homing(rank, o_snd, o_rcv))
+            r_snd.get_alpha(),
+            self.__update_load(r_snd, o_snd, o_rcv),
+            self.__update_received(r_snd, o_snd, o_rcv),
+            self.__update_sent(r_snd, o_snd, o_rcv),
+            self.__update_homing(r_snd, o_snd, o_rcv))

src/lbaf/Model/lbsNode.py

@@ -78,6 +78,14 @@ def add_rank(self, rank):
     def get_number_of_ranks(self) -> int:
         return len(self.__ranks)
 
+    def get_objects(self) -> set:
+        """Return set of all objects across all ranks in node."""
+        return set().union(*(r.get_objects() for r in self.get_ranks()))
+    
+    def get_shared_blocks(self) -> set:
+        """Return set of all shared blocks across all ranks in node."""
+        return set().union(*(r.get_shared_blocks() for r in self.get_ranks()))
+
     def get_max_memory_usage(self) -> float:
         """Sum all memory usages for each rank to get the node memory usage."""
         return 0.0 + sum(

src/lbaf/Model/lbsWorkModelBase.py

@@ -83,6 +83,6 @@ def compute(self, rank):
         # Must be implemented by concrete subclass
 
     @abc.abstractmethod
-    def update(self, rank, o_snd, o_rcv):
-        """Compute updated work on given rank if sending and receiving objects."""
+    def update(self, r_snd, r_rcv, o_snd, o_rcv):
+        """Compute updated work on sender rank if sending and receiving objects."""
         # Must be implemented by concrete subclass