fixup! fixup! fixup! fixup! fixup! fixup! fixup! Try another approachbschubert/rework-sort

1 files changed, 94 insertions, 50 deletions

diff --git a/buildstream/_loader/loader.py b/buildstream/_loader/loader.py
index b5ae830d8..cdd3c04f3 100644
--- a/buildstream/_loader/loader.py
+++ b/buildstream/_loader/loader.py
@@ -150,7 +150,7 @@ class Loader():
         #
         key = "-".join([e.name for e in target_elements])
         profile_start(Topics.COLLECT_ELEMENTS, key)
-        ret = loader._collect_elements(target_elements)
+        loader._collect_elements(target_elements)
         profile_end(Topics.COLLECT_ELEMENTS, key)
 
         # print("#" * 60)
@@ -165,7 +165,7 @@ class Loader():
         # print("#" * 60)
 
 
-        return ret
+        return [element._loader._meta_elements[element.name] for element in target_elements]
 
     # cleanup():
     #
@@ -390,13 +390,13 @@ class Loader():
         return meta_element
 
     def _collect_elements(self, elements):
-        all_elements = set()
-        elements_to_process = set(elements)
+        # all_elements = set()
+        # elements_to_process = set(elements)
 
-        while elements_to_process:
-            element = elements_to_process.pop()
-            all_elements.add(element)
-            elements_to_process.update([d.element for d in element.dependencies])
+        # while elements_to_process:
+        #     element = elements_to_process.pop()
+        #     all_elements.add(element)
+        #     elements_to_process.update([d.element for d in element.dependencies])
 
         def sorter(element_a, element_b):
             if element_a.name > element_b.name:
@@ -427,53 +427,38 @@ class Loader():
 
             return sorter(dep_a.element, dep_b.element)
 
-        def not_visited(dep):
-            return not dep.element.visited
+        # def not_visited(dep):
+        #     return not dep.element.visited
 
-        all_elements = deque(sorted(all_elements, key=cmp_to_key(sorter)))
+        # all_elements = deque(sorted(all_elements, key=cmp_to_key(sorter), reverse=True))
 
-        treated_elements = []
+        # while all_elements:
 
-        # print("-" * 60)
-        while all_elements:
-            # print([e.name for e in all_elements])
-            current = all_elements.popleft()
+        # elements_to_process = deque(sorted(all_elements, key=cmp_to_key(sorter), reverse=True)
+        next_iteration = list(elements)
 
-            if current.visited:
-                continue
-
-            missing_deps = [
-                dep.element
-                for dep in sorted(filter(not_visited, current.dependencies), key=cmp_to_key(compare_unprocessed), reverse=True)
+        while next_iteration:
+            current_iteration = [
+                element
+                for element in next_iteration
+                if all(dep.element.visited for dep in element.reverse_dependencies)
             ]
+            next_iteration = []
 
-            if missing_deps:
-                for entry in missing_deps:
-                    all_elements.remove(entry)
-
-                # print(current.name, "bumped")
-                # print("Adding", [d.name for d in missing_deps])
-                all_elements.appendleft(current)
-                all_elements.extendleft(missing_deps)
-                continue
+            for element in current_iteration:
+                element.visited = True
+                meta_element = self._collect_element(element)
 
-            current.visited = True
-            treated_elements.append(current)
 
-        all_elements = deque(treated_elements)
-
-        # Filter out duplicated elements
-        for _ in range(len(all_elements)):
-            current = all_elements.popleft()
-            if not current.visited:
+        for element in elements:
+            if element.visited:
+                # print("Skipping...", element.name)
                 continue
 
-            current.visited = False
-            all_elements.append(current)
-
-        for element in all_elements:
-            meta_element = element._loader._collect_element(element)
+            # print(element.name)
 
+            self._collect_elements(d.element for d in sorted(element.dependencies, key=cmp_to_key(compare_unprocessed)))
+            meta_element = self._collect_element(element)
             for dep in element.dependencies:
                 dependency = dep.element._loader._meta_elements[dep.element.name]
                 if dep.dep_type != Symbol.RUNTIME:
@@ -481,10 +466,69 @@ class Loader():
                 if dep.dep_type != Symbol.BUILD:
                     meta_element.dependencies.append(dependency)
 
-        # print("------------------")
-        for element in self._meta_elements.values():
-            element.build_dependencies.sort(key=attrgetter("index"))
-            element.dependencies.sort(key=attrgetter("index"))
+            meta_element.dependencies.sort(key=attrgetter("index"))
+            meta_element.build_dependencies.sort(key=attrgetter("index"))
+
+
+            # next_missing_dep = next(filter())
+            # missing_deps = [
+            #     dep.element
+            #     for dep in sorted(filter(not_visited, current.dependencies))
+            # ]
+
+        # treated_elements = []
+
+        # # print("-" * 60)
+        # while all_elements:
+        #     # print([e.name for e in all_elements])
+        #     current = all_elements.popleft()
+
+        #     if current.visited:
+        #         continue
+
+        #     missing_deps = [
+        #         dep.element
+        #         for dep in sorted(filter(not_visited, current.dependencies), key=cmp_to_key(compare_unprocessed), reverse=True)
+        #     ]
+
+        #     if missing_deps:
+        #         for entry in missing_deps:
+        #             all_elements.remove(entry)
+
+        #         # print(current.name, "bumped")
+        #         # print("Adding", [d.name for d in missing_deps])
+        #         all_elements.appendleft(current)
+        #         all_elements.extendleft(missing_deps)
+        #         continue
+
+        #     current.visited = True
+        #     treated_elements.append(current)
+
+        # all_elements = deque(treated_elements)
+
+        # # Filter out duplicated elements
+        # for _ in range(len(all_elements)):
+        #     current = all_elements.popleft()
+        #     if not current.visited:
+        #         continue
+
+        #     current.visited = False
+        #     all_elements.append(current)
+
+        # for element in all_elements:
+        #     meta_element = element._loader._collect_element(element)
+
+        #     for dep in element.dependencies:
+        #         dependency = dep.element._loader._meta_elements[dep.element.name]
+        #         if dep.dep_type != Symbol.RUNTIME:
+        #             meta_element.build_dependencies.append(dependency)
+        #         if dep.dep_type != Symbol.BUILD:
+        #             meta_element.dependencies.append(dependency)
+
+        # # print("------------------")
+        # for element in self._meta_elements.values():
+        #     element.build_dependencies.sort(key=attrgetter("index"))
+        #     element.dependencies.sort(key=attrgetter("index"))
         #     print("element:", element.name, [e.name for e in element.build_dependencies], [e.name for e in element.dependencies])
         # print("####################")
 
@@ -607,9 +651,9 @@ class Loader():
         #     element.build_dependencies.sort(key=attrgetter("index"), reverse=True)
         #     element.dependencies.sort(key=attrgetter("index"), reverse=True)
 
-        ret = [e._loader._collect_element(e) for e in elements]
+        # ret = [e._loader._collect_element(e) for e in elements]
 
-        return ret
+        # return ret
 
     # _get_loader():
     #