Merge pull request #23 from costa-group/var_order

Var order

Author: alexcere

scripts/compare_blocks.py

@@ -173,13 +173,16 @@ def is_terminal(block):
 def process_terminal_blocks(blocks, num_pops):
     terminal_blocks = 0
     total_pops = []
+    total_ins_terminal = 0
+    
     for bl in blocks:
         process_pops(bl, total_pops)
         if is_terminal(bl):
             terminal_blocks+=1
+            total_ins_terminal+=len(bl)
             process_pops(bl,num_pops)
 
-    return terminal_blocks, sum(total_pops)
+    return terminal_blocks, sum(total_pops), total_ins_terminal
 
 def count_num_ins(evm: str):
     """
@@ -190,15 +193,17 @@ def count_num_ins(evm: str):
     num_pop = []
     terminal_blocks = 0
     total_pops = 0
+    total_ins_terminal = 0
     for region in code_regions:
         blocks = get_blocks(remove_auxdata(region))
-        num_tblocks, numtotal_pops = process_terminal_blocks(blocks, num_pop)
+        num_tblocks, numtotal_pops, ins_terminal = process_terminal_blocks(blocks, num_pop)
         terminal_blocks+=num_tblocks
         total_pops+=numtotal_pops
-
+        total_ins_terminal+=ins_terminal
+        
     #print("TERMINAL BLOCKS: " +str(terminal_blocks))
     #print("NUM_POPS: "+ str(sum(num_pop)))
-    return (terminal_blocks, sum(num_pop), total_pops)
+    return (terminal_blocks, sum(num_pop), total_pops, total_ins_terminal)
 
 
 def execute_function(origin_file, log_opt_file):
@@ -217,6 +222,9 @@ def execute_function(origin_file, log_opt_file):
 
     all_pops_opt = 0
     all_pops_sol = 0
+
+    total_ins_terminal_opt = 0
+    total_ins_terminal_sol = 0
 
     for c in evm_opt:
         evm = evm_opt[c]
@@ -226,6 +234,7 @@ def execute_function(origin_file, log_opt_file):
         total_terminal+=opt[0]
         total_pops+=opt[1]
         all_pops_opt+=opt[2]
+        total_ins_terminal_opt = opt[3]
 
         evm_dict = js.loads(evm_origin)
         contracts = evm_dict["contracts"]
@@ -239,10 +248,12 @@ def execute_function(origin_file, log_opt_file):
                 bytecode = json[c.strip()]["evm"]["bytecode"]["object"]
                 # print("ORIGINAL")
                 origin_ins =count_num_ins(bytecode.strip())
+                
                 total_sol_terminal+=origin_ins[0]
                 total_sol_pops+=origin_ins[1]
                 all_pops_sol+=origin_ins[2]
-    return (total_terminal, total_pops, all_pops_opt, total_sol_terminal, total_sol_pops, all_pops_sol)
+                total_ins_terminal_sol+=origin_ins[3]
+    return (total_terminal, total_pops, all_pops_opt, total_sol_terminal, total_sol_pops, all_pops_sol, total_ins_terminal_opt, total_ins_terminal_sol)
 
 if __name__ == '__main__':
     origin_file = sys.argv[1]

scripts/sum_instructions.py

@@ -62,6 +62,9 @@ def cuartiles(original, optimizado, res):
 total_origin_pops = 0
 all_pops_origin = 0
 
+total_ins_terminal_sol = 0
+total_ins_terminal_opt = 0
+
 for i in range(len(origin_number)):
     original = origin_number[i]
     optimizado = opt_number[i]
@@ -79,14 +82,16 @@ def cuartiles(original, optimizado, res):
 
         fname_without_ext = fname.rstrip("log")
 
-        tsol, pops_sol, allpops, torigin, pops_origin , allpops_orig = compare_blocks.execute_function(fname_without_ext+"output", fname_without_ext+"log")
+        tsol, pops_sol, allpops, torigin, pops_origin , allpops_orig, inst_opt, inst_sol = compare_blocks.execute_function(fname_without_ext+"output", fname_without_ext+"log")
 
         total_sol_terminal+=tsol
         total_sol_pops+=pops_sol
         all_pops_sol+= allpops
         total_origin_terminal+=torigin
         total_origin_pops+=pops_origin
         all_pops_origin+=allpops_orig
+        total_ins_terminal_sol+=inst_sol
+        total_ins_terminal_opt+=inst_opt
 
         worse_files[fname] = (original, optimizado)
         # print("PAREJA: ("+str(original)+","+str(optimizado)+")")
@@ -114,6 +119,9 @@ def cuartiles(original, optimizado, res):
 
 print("TOTAL POPS IN SOLUTION: "+str(all_pops_sol))
 print("TOTAL POPS IN ORIGINAL: "+str(all_pops_origin))
+
+print("TOTAL INS TERMINAL BLOCKS IN SOLUTION: "+str(total_ins_terminal_opt))
+print("TOTAL INS TERMINAL BLOCKS IN ORIGINAL: "+str(total_ins_terminal_sol)) 
 print()
 
 print(" ===== NUM INSTRUCTIONS STATISTICS ===== ")

src/liveness/stack_layout_methods.py

@@ -53,7 +53,7 @@ def remove_backwards_edges(current_node, visited: Set, current_path: Set, cfg:nx
 
 
 def compute_variable_depth(liveness_info: Dict[str, LivenessAnalysisInfoSSA], topological_order: List) -> Dict[
-    str, Dict[str, Tuple[int, int]]]:
+    str, Dict[str, Tuple[int, int, int]]]:
     """
     For each variable at every point in the CFG, returns the corresponding depth of the last time a variable was used
     and the position being used in the current block (if any). Useful for determining in which order
@@ -63,19 +63,17 @@ def compute_variable_depth(liveness_info: Dict[str, LivenessAnalysisInfoSSA], to
     variable_depth_out = dict()
     variable_depth_in = dict()
     max_depth = len(topological_order) + 1
+    max_instr_idx = 100
 
     for node in reversed(topological_order):
         block_info = liveness_info[node].block_info
         instructions = block_info.instructions
-        max_instr_idx = len(instructions) + 1
 
         current_variable_depth_out = dict()
 
         # Initialize variables in the live_in set to len(topological_order) + 1
-        for input_variable in liveness_info[node].in_state.live_vars:
-            current_variable_depth_out[input_variable] = max_depth, max_instr_idx
-
-        # Link each variable to the position being used in the instructions
+        for input_variable in liveness_info[node].out_state.live_vars:
+            current_variable_depth_out[input_variable] = max_depth, max_instr_idx, max_instr_idx
 
         # For each successor, compute the variable depth information and update the corresponding map
         for succ_node in block_info.successors:
@@ -84,27 +82,28 @@ def compute_variable_depth(liveness_info: Dict[str, LivenessAnalysisInfoSSA], to
             # as we will visit it later
             previous_variable_depth = variable_depth_in.get(succ_node, dict())
 
-            for variable, depth in previous_variable_depth.items():
+            for variable, previous_variable_info in previous_variable_depth.items():
                 # Update the depth if it already appears in the dict
                 variable_info = current_variable_depth_out.get(variable, None)
                 if variable_info is not None:
-                    var_depth, instr_pos = variable_info
                     # If the depth of the successor variable is less than the one we have actually
-                    if variable_info >= depth:
-                        current_variable_depth_out[variable] = variable_info
+                    if variable_info > previous_variable_info:
+                        current_variable_depth_out[variable] = previous_variable_info[0] + 1, previous_variable_info[1], previous_variable_info[2]
                 else:
-                    current_variable_depth_out[variable] = depth[0] + 1, max_instr_idx
+                    current_variable_depth_out[variable] = previous_variable_info[0] + 1, previous_variable_info[1], previous_variable_info[2]
 
+        # Afterwards, we update the information of the in set
         current_variable_depth_in = current_variable_depth_out.copy()
 
-        # Finally, we update the corresponding variables that are defined in the blocks
-        # for used_variable in set(block_info.uses).union(block_info.phi_uses):
-        #     current_variable_depth_out[used_variable] = 0
+        # Link each variable to the position being used in the instructions
+        for i, instruction in enumerate(instructions):
+            for j, in_arg in enumerate(instruction.in_args):
+                current_variable_depth_in[in_arg] = 0, i, j
 
         variable_depth_out[node] = current_variable_depth_out
         variable_depth_in[node] = current_variable_depth_in
 
-    return variable_depth_out
+    return variable_depth_in
 
 
 def compute_block_level(dominance_tree: nx.DiGraph, start: str) -> Dict[str, int]:
@@ -161,7 +160,7 @@ def output_stack_layout(input_stack: List[str], final_stack_elements: List[str],
     vars_to_place = live_vars.difference(set(final_stack_elements + bottom_output_stack))
 
     # Sort the vars to place according to the variable depth info order in reversed order
-    vars_to_place_sorted = sorted(vars_to_place, key=lambda x: (*variable_depth_info[x], x), reverse=True)
+    vars_to_place_sorted = sorted(vars_to_place, key=lambda x: (variable_depth_info[x], x), reverse=True)
 
     # Try to place the variables in reversed order
     i, j = len(bottom_output_stack) - 1, 0