memory optimized sort_vars

code/code_gen/post.py

@@ -472,13 +472,13 @@ class Stage3():
 
         pass1calc = set(map(repr, self.avg1))
         map (pass1calc.update, map(AveragedField.depClosure, self.avg1))
-        self.pass1 = self.sort_vars(self.dependency, pass1calc - self.primary)
+        self.pass1 = self.sort_vars_new(self.dependency, pass1calc - self.primary)
 
         # self.sort_vars(self.dependency, pass1calc - self.primary -set(map(repr, self.avg1)))
 
         pass2calc = set(map(repr, self.avg2))
         map (pass2calc.update, map(AveragedField.depClosure, self.avg2))
-        self.pass2 = self.sort_vars(self.dependency, pass2calc - self.primary)
+        self.pass2 = self.sort_vars_new(self.dependency, pass2calc - self.primary)
 
 
     def __repr__ (self):
@@ -498,6 +498,48 @@ class Stage3():
 
         return order
 
+    def calc_size (self, ordered, remaining):
+        count = 0
+        dep_union = set([])
+
+        g = self.dependency
+        
+        for v in remaining:
+            dep_union |= set(g[v])
+            
+        for v in ordered:
+            if v in dep_union:
+                count += 1
+            
+        return count
+
+
+    def sort_vars_new (self, dependency, group):
+        order = []
+        remain = list(group)
+        remain.sort()
+
+        while len(remain) > 0:
+            
+            candidate = []
+            for v in remain:
+                if set(dependency[v]).isdisjoint(remain):
+                    candidate.append(v)
+
+            impact = {}
+            
+            size0 = self.calc_size(set(order), set(remain))
+
+            for v in candidate:
+                impact[v] = self.calc_size(set(order) | set([v]), set(remain) - set([v])) - size0
+                
+            candidate.sort(key=impact.get)
+            
+            order.append(candidate[0])
+            remain.remove(candidate[0])
+
+        return order
+
 
     def print_program (self):