#386: eliminate duplicated code in BruteForceAlgorithm and LBAF_App +…

… use loaded `Object` instances instead of dictionaries

src/lbaf/Applications/LBAF_app.py

@@ -364,24 +364,7 @@ def run(self):
             and self.__parameters.algorithm["name"] != "BruteForce"):
             # Prepare input data for rank order enumerator
             self.__logger.info("Starting brute force optimization")
-            objects = []
-
-            # Iterate over ranks
-            for rank in initial_phase.get_ranks():
-                for o in rank.get_objects():
-                    entry = {
-                        "id": o.get_id(),
-                        "load": o.get_load(),
-                        "to": {},
-                        "from": {}}
-                    comm = o.get_communicator()
-                    if comm:
-                        for k, v in comm.get_sent().items():
-                            entry["to"][k.get_id()] = v
-                        for k, v in comm.get_received().items():
-                            entry["from"][k.get_id()] = v
-                    objects.append(entry)
-            objects.sort(key=lambda x: x.get("id"))
+            objects = initial_phase.get_objects()
 
             # Execute rank order enumerator and fetch optimal arrangements
             alpha, beta, gamma = [

src/lbaf/Applications/rank_object_enumerator.py

@@ -190,23 +190,7 @@ def get_conf() -> dict:
 
     # Get objects from log files
     initial_phase = phases[min(phases.keys())]
-    objects = []
-    # Iterate over ranks
-    for rank in initial_phase.get_ranks():
-        for o in rank.get_objects():
-            entry = {
-                "id": o.get_id(),
-                "load": o.get_load(),
-                "to": {},
-                "from": {}}
-            comm = o.get_communicator()
-            if comm:
-                for k, v in comm.get_sent().items():
-                    entry["to"][k.get_id()] = v
-                for k, v in comm.get_received().items():
-                    entry["from"][k.get_id()] = v
-            objects.append(entry)
-    objects.sort(key=lambda x: x.get("id"))
+    objects = initial_phase.get_objects()
 
     # Print out input parameters
     root_logger.info(f"alpha: {alpha_g}")

src/lbaf/Execution/lbsBruteForceAlgorithm.py

@@ -40,21 +40,21 @@ def compute_arrangement_works(self, objects: tuple, arrangement: tuple) -> dict:
             # Compute load component for current rank
             values = {
                 "load":
-                sum([objects[i].get("load") for i in rank_object_ids])}
+                sum([objects[i].get_load() for i in rank_object_ids])}
 
             # Compute received communication volume
             v = 0.0
             for i in rank_object_ids:
                 v += sum([
-                    v for k, v in objects[i].get("from", 0.).items()
+                    v for k, v in objects[i].get_communicator().get_received().items()
                     if k not in rank_object_ids])
             values["received volume"] = v
 
             # Compute sent communication volume
             v = 0.0
             for i in rank_object_ids:
                 v += sum([
-                    v for k, v in objects[i].get("to", 0.).items()
+                    v for k, v in objects[i].get_sent().items()
                     if k not in rank_object_ids])
             values["sent volume"] = v
 
@@ -73,31 +73,14 @@ def execute(self, p_id: int, phases: list, distributions: dict, statistics: dict
         self._logger.info("Starting brute force optimization")
         objects = []
 
-        # Iterate over ranks
         initial_phase = phases[min(phases.keys())]
-        phase_ranks = initial_phase.get_ranks()
-        for rank in phase_ranks:
-            for o in rank.get_objects():
-                entry = {
-                    "id": o.get_id(),
-                    "rank": rank,
-                    "load": o.get_load(),
-                    "to": {},
-                    "from": {}}
-                comm = o.get_communicator()
-                if comm:
-                    for k, v in comm.get_sent().items():
-                        entry["to"][k.get_id()] = v
-                    for k, v in comm.get_received().items():
-                        entry["from"][k.get_id()] = v
-                objects.append(entry)
-        objects.sort(key=lambda x: x.get("id"))
+        objects = initial_phase.get_objects()
 
         # Initialize quantities of interest
         n_arrangements = 0
         w_min_max = math.inf
         a_min_max = []
-        n_ranks = len(phase_ranks)
+        n_ranks = len(initial_phase.get_ranks())
 
         # Compute all possible arrangements with repetition and minimax work
         for arrangement in itertools.product(range(n_ranks), repeat=len(objects)):

src/lbaf/IO/lbsStatistics.py

@@ -161,7 +161,7 @@ def compute_volume(objects: tuple, rank_object_ids: list, direction: str) -> flo
     volume = 0.
 
     # Iterate over all rank objects
-    for i in rank_object_ids:
+    for _ in rank_object_ids:
         volume += sum(v for (k, v) in getattr(objects[0], direction, {}).items() if k not in rank_object_ids)
 
     # Return computed volume
@@ -172,7 +172,7 @@ def compute_load(objects: tuple, rank_object_ids: list) -> float:
     """Return a load as a sum of all object loads
     """
 
-    return sum([objects[i].get('load') for i in rank_object_ids])
+    return sum([objects[i].get_load() for i in rank_object_ids])
 
 
 def compute_arrangement_works(objects: tuple, arrangement: tuple, alpha: float, beta: float, gamma: float) -> dict:
@@ -190,8 +190,8 @@ def compute_arrangement_works(objects: tuple, arrangement: tuple, alpha: float,
         works[rank] = alpha * compute_load(objects, rank_objects)
 
         # Compute communication volumes
-        works[rank] += beta * max(compute_volume(objects, rank_objects, "from"),
-                                  compute_volume(objects, rank_objects, "to"))
+        works[rank] += beta * max(compute_volume(objects, rank_objects, "received"),
+                                  compute_volume(objects, rank_objects, "sent"))
 
         # Add constant
         works[rank] += gamma

src/lbaf/Model/lbsPhase.py

@@ -82,13 +82,34 @@ def get_number_of_objects(self):
         return sum([r.get_number_of_objects() for r in self.__ranks])
 
     def get_objects(self):
-
         """Return all objects belonging to phase."""
 
         # List comprehension is not possible as we need to use set to list concatenation
         objects = []
-        for r in self.__ranks:
-            objects += r.get_objects()
+        for rank in self.__ranks:
+            objects += rank.get_objects()
+        objects.sort(key=lambda x: x.get_id())
+        return objects
+
+    def get_objects_dict(self):
+        """Return all objects as dictionaries with `from` and `to` values retrieved from the object communicator"""
+
+        objects = []
+        for o in self.get_objects():
+            entry = {
+                "id": o.get_id(),
+                "rank": o.get_rank_id(),
+                "load": o.get_load(),
+                "to": {},
+                "from": {}}
+            comm = o.get_communicator()
+            if comm:
+                for k, v in comm.get_sent().items():
+                    entry["to"][k.get_id()] = v
+                for k, v in comm.get_received().items():
+                    entry["from"][k.get_id()] = v
+            objects.append(entry)
+        objects.sort(key=lambda x: x.get("id"))
         return objects
 
     def get_object_ids(self):