fix bugs

theano/compile/profiling.py

@@ -690,6 +690,72 @@ class ProfileStats(object):
 
             return [node_memory_size, running_memory_size, running_max_memory_size, node_memory_saved_by_inplace, node_memory_saved_by_view]
 
+        def count_minimum_peak(node_list, fgraph, nodes_mem):
+            mem_list = []
+            current_mem = 0
+            order_index = 0
+            min_mem = 0
+            order = []
+
+            compute_map = fgraph.profile.compute_map
+            # compute_map use to check if a node is valid
+
+            def check_node_state(node):
+                """
+                check if an Apply node is valid(has inputs but no outputs).
+
+                :param node: apply node
+                """
+                inputs = node.inputs
+                outputs = node.outputs
+                deps = inputs + node.destroy_dependencies
+                computed_ins = all(compute_map[v][0] for v in deps)
+                computed_outs = all(compute_map[v][0] for v in outputs)
+                # check if there could be a compute_map
+                if computed_ins and not computed_outs:
+                    return True
+                else:
+                    return False
+
+            def min_memory_generator(node_list, b=False):
+                global mem_list, current, order_index, min_mem
+                '''
+                enumerate all valid order( node with inputs in its compute_map)
+                compute the peak of all order and keep the order with the minimum peak.
+                return an order with minimum memory usage
+
+                :param node_list: a list of apply nodes
+                '''
+                
+                for i in range(len(node_list)):
+                    v = node_list[i:i+1]
+                    if check_state(v[0]): 
+                        if len(node_list) == 1:
+                            yield v
+                            current_mem += nodes_mem[v[0]]
+                            b = True
+                        else:
+                            b = False
+                            rest = node_list[ :i] + node_list[i+1: ]
+                            for p in count_min_memory_peak(rest):
+                                yield v+p
+                                current_mem += nodes_mem[v[0]]
+                if b:
+                    mem_list.append(current_mem)
+                    if not min_mem:
+                        min_mem = current_mem 
+                    if current_mem < min_mem:
+                        min_mem = current_mem
+                        order_index = mem_list.index(current_mem)
+                    current_mem = 0
+
+            gen = min_memory_generator(node_list)
+
+            for i in range(0, (order_index+1)):
+                order = gen.next()
+
+            return order, min_mem
+
         for fgraph, nodes_mem in fct_memory.iteritems():
             # Sum of the size of all variables in bytes
             sum_size = sum([sum([v for v in val if not isinstance(v, str)])
@@ -740,7 +806,7 @@ class ProfileStats(object):
 
 
             node_list = fgraph.nodes
-            _, minimum_peak = count_minimum_peak(node_list, fgraph)
+            _, minimum_peak = count_minimum_peak(node_list, fgraph, nodes_mem)
             # for the best order, we dont use it now
             max_minimum_peak = max(max_minimum_peak, minimum_peak)
             
@@ -866,83 +932,7 @@ class ProfileStats(object):
             self.optimizer_profile[0].print_profile(file,
                                                     self.optimizer_profile[1])
 
-    def count_minimum_peak(node_list, fgraph):
-        mem_list = []
-        current_mem = 0
-        order_index = 0
-        min_mem = 0
-        order = []
-
-        compute_map = fgraph.profile.compute_map
-        # compute_map use to check if a node is valid
-
-        node_mem = {}
-        for node in self.apply_callcount.keys():
-            sum_dense = 0
-            for out in node.outputs:
-                sh = self.variable_shape[out]
-                if hasattr(out.type, 'get_size'):
-                    v = out.type.get_size(sh)
-                    sum_dense += v
 
-            node_mem[node] = sum_dense
-        # node_mem use to calculate the node memory usage 
-
-        def check_node_state(node):
-            """
-            check if an Apply node is valid(has inputs but no outputs).
-
-            :param node: apply node
-            """
-            inputs = node.inputs
-            outputs = node.outputs
-            deps = inputs + node.destroy_dependencies
-            computed_ins = all(compute_map[v][0] for v in deps)
-            computed_outs = all(compute_map[v][0] for v in outputs)
-            # check if there could be a compute_map
-            if computed_ins and not computed_outs:
-                return True
-            else:
-                return False
-
-        def min_memory_generator(node_list, b=False):
-            global mem_list, current, order_index, min_mem
-            '''
-            enumerate all valid order( node with inputs in its compute_map)
-            compute the peak of all order and keep the order with the minimum peak.
-            return an order with minimum memory usage
-
-            :param node_list: a list of apply nodes
-            '''
-            
-            for i in range(len(node_list)):
-                v = node_list[i:i+1]
-                if check_state(v[0]): 
-                    if len(node_list) == 1:
-                        yield v
-                        current_mem += node_mem[v[0]]
-                        b = True
-                    else:
-                        b = False
-                        rest = node_list[ :i] + node_list[i+1: ]
-                        for p in count_min_memory_peak(rest):
-                            yield v+p
-                            current_mem += node_mem[v[0]]
-            if b:
-                mem_list.append(current_mem)
-                if not min_mem:
-                    min_mem = current_mem 
-                if current_mem < min_mem:
-                    min_mem = current_mem
-                    order_index = mem_list.index(current_mem)
-                current_mem = 0
-
-        gen = min_memory_generator(node_list)
-
-        for i in range(0, (order_index+1)):
-            order = gen.next()
-
-        return order, min_mem
 
 
 if 0: # old code still to be ported from ProfileMode