Optimizations

Author: simon816

compiler/asm_extensions.py

@@ -12,7 +12,8 @@ def __init__(self, pos, writer, namespace, page_size=64, **kwargs):
             'memory_buffer': 'mb',
             'memory_slot': ('ms_%d', range(self.page_size))
         })
-        self.add_page()
+        if page_size > 0:
+            self.add_page()
 
     def add_page(self):
         mbr = Var('memory_buffer')
@@ -113,6 +114,7 @@ def __init__(self):
             'MOVINDD': self.handle_mov_ind_d,
             'MOVINDS': self.handle_mov_ind_s
         })
+        self.use_mem = False
 
     def handle_ret(self):
         if not self.enable_sync:
@@ -122,6 +124,7 @@ def handle_ret(self):
 
     def handle_mov_ind(self, src, s_off, dest, d_off):
         """Move indirect src to indirect dest"""
+        self.use_mem = True
         src, dest = self.get_src_dest(src, dest)
         s_off = self.resolve_ref(*s_off)
         d_off = self.resolve_ref(*d_off)
@@ -140,6 +143,7 @@ def handle_mov_ind(self, src, s_off, dest, d_off):
 
     def handle_mov_ind_d(self, src, dest, d_off):
         """Move src to indirect dest"""
+        self.use_mem = True
         src, dest = self.get_src_dest(src, dest)
         offset = self.resolve_ref(*d_off)
         assert type(offset) == int
@@ -152,6 +156,7 @@ def handle_mov_ind_d(self, src, dest, d_off):
 
     def handle_mov_ind_s(self, src, s_off, dest):
         """Move indirect src to dest"""
+        self.use_mem = True
         src, dest = self.get_src_dest(src, dest)
         offset = self.resolve_ref(*s_off)
         assert type(offset) == int

compiler/compiler.py

@@ -861,6 +861,7 @@ def __init__(self, ir_downstream):
         self.current_function = None
         self.loop_attacher = LoopAttacher(None, None, self, None)
         self.python_functions = {}
+        self.temp_slots = set()
         self.pragmas = {}
 
     def import_py_lib(self, lib_exports):
@@ -918,6 +919,14 @@ def unique_label(self, label):
         self.local_labels[label] += 1
         return IR.Label('%s_%d' %(label, self.local_labels[label]))
 
+    def consume_slot(self, slot):
+        if slot in self.temp_slots:
+            self.temp_slots.remove(slot)
+            self.emit(IR.Free(slot))
+
+    def virtual_slot(self, slot):
+        self.temp_slots.add(slot)
+
     ### Pragmas
 
     def visit_pragma(self, pragma):
@@ -1169,6 +1178,7 @@ def visit_func_decl(self, decl):
         self.current_function = func_symbol
 
         self.local_labels = {}
+        self.temp_slots.clear()
 
         pragma = {}
         # check pragmas
@@ -1342,6 +1352,7 @@ def visit_while_stmt(self, stmt):
             self.emit(begin)
             cond = self.visit_expression(stmt.cond)
             self.emit(IR.JumpIfNot(end, cond))
+            self.consume_slot(cond)
             self.visit_statement(stmt.body)
             self.emit(IR.Jump(begin))
             self.emit(end)
@@ -1355,21 +1366,23 @@ def visit_do_while_stmt(self, stmt):
             self.emit(cond_label)
             cond = self.visit_expression(stmt.cond)
             self.emit(IR.JumpIf(begin, cond))
+            self.consume_slot(cond)
             self.emit(end)
 
     def visit_for_stmt(self, stmt):
         with self.loop(continue_='for_cont', break_='end_for') as (after_label, end):
             if stmt.init:
-                self.visit_expression(stmt.init)
+                self.consume_slot(self.visit_expression(stmt.init))
             cond_label = self.unique_label('for')
             self.emit(cond_label)
             if stmt.cond:
                 cond = self.visit_expression(stmt.cond)
                 self.emit(IR.JumpIfNot(end, cond))
+                self.consume_slot(cond)
             self.visit_statement(stmt.body)
             self.emit(after_label)
             if stmt.after:
-                self.visit_expression(stmt.after)
+                self.consume_slot(self.visit_expression(stmt.after))
             self.emit(IR.Jump(cond_label))
             self.emit(end)
 
@@ -1379,6 +1392,7 @@ def visit_if_stmt(self, stmt):
 
         cond = self.visit_expression(stmt.cond)
         self.emit(IR.JumpIfNot(false_label, cond))
+        self.consume_slot(cond)
 
         if self.exists(stmt.true):
             self.visit_statement(stmt.true)
@@ -1415,6 +1429,7 @@ def visit_switch_stmt(self, stmt):
                 self.emit_op(IR.Op.Eq, option, self.int(choice), res)
                 self.emit(IR.JumpIf(dest, res))
             self.emit(IR.Jump(default_label))
+            self.consume_slot(option)
 
             for label, body in case_bodies:
                 self.emit(label)
@@ -1444,6 +1459,7 @@ def visit_return_stmt(self, stmt):
                 # for the return value, so store it there
                 dest = self.offset(IR.StackPointer, -ret_type.size, ret_type)
                 self.emit(IR.Move(ret_val, dest))
+            self.consume_slot(ret_val)
         self.emit(IR.Return())
 
     def visit_goto_stmt(self, stmt):
@@ -1453,7 +1469,7 @@ def visit_sync_stmt(self, stmt):
         self.emit(IR.Sync())
 
     def visit_expr_stmt(self, stmt):
-        self.visit_expression(stmt.expr)
+        self.consume_slot(self.visit_expression(stmt.expr))
 
     ### Expressions
 
@@ -1523,6 +1539,7 @@ def visit_binop_expr(self, expr):
         op = IR.Op.lookup(expr.op)
         res = mk_slot(left.type)
         self.emit_op(op, left, right, res)
+        self.virtual_slot(res)
         return res
 
     def visit_member_access_expr(self, expr):

compiler/ir.py

@@ -337,6 +337,8 @@ def init(self):
     def emit(self, insn):
         if not self.dead:
             super().emit(insn)
+        else:
+            self.success()
 
     def handle_entity_local(self, insn):
         self.dead = False
@@ -354,6 +356,10 @@ def handle_jump(self, insn):
         self.emit(insn)
         self.dead = True
 
+    def handle_return(self, insn):
+        self.emit(insn)
+        self.dead = True
+
     def handle_label(self, insn):
         self.dead = False
         self.emit(insn)
@@ -432,6 +438,12 @@ class ConstantElimination(OptimizerVisitor):
 
     def init(self):
         self.slot_value_map = {}
+        self.slot_ref_map = {}
+        self.clear()
+
+    def clear(self):
+        self.slot_value_map = {}
+        self.slot_ref_map = {}
 
     def literal(self, ref):
         if isinstance(ref, IR.LiteralInt):
@@ -444,19 +456,19 @@ def int(self, val):
         return IR.LiteralInt(val, IntType())
 
     def handle_fn_begin(self, insn):
-        self.slot_value_map = {}
+        self.clear()
         self.emit(insn)
 
     def handle_label(self, insn):
-        self.slot_value_map = {}
+        self.clear()
         self.emit(insn)
 
     def handle_jump(self, insn):
-        self.slot_value_map = {}
+        self.clear()
         self.emit(insn)
 
     def handle_jump_if(self, insn):
-        self.slot_value_map = {}
+        self.clear()
         cond = self.literal(insn.cond)
         if cond is not None:
             self.success()
@@ -468,7 +480,7 @@ def handle_jump_if(self, insn):
             self.emit(insn)
 
     def handle_jump_if_not(self, insn):
-        self.slot_value_map = {}
+        self.clear()
         cond = self.literal(insn.cond)
         if cond is not None:
             self.success()
@@ -480,13 +492,27 @@ def handle_jump_if_not(self, insn):
             self.emit(insn)
 
     def handle_call(self, insn):
-        self.slot_value_map = {}
+        self.clear()
         self.emit(insn)
 
     def handle_move(self, insn):
         val = self.literal(insn.src)
         if val is not None:
             self.slot_value_map[insn.dest] = val
+        if insn.src == insn.dest: # useless move
+            self.success()
+            return
+        if insn.dest in self.slot_ref_map:
+            prev_val = self.slot_ref_map[insn.dest]
+            if insn.src == prev_val: # useless move
+                self.success()
+                return
+        if insn.src in self.slot_ref_map:
+            src_ref = self.slot_ref_map[insn.src]
+            if src_ref == insn.dest: # useless move
+                self.success()
+                return
+        self.slot_ref_map[insn.dest] = insn.src
         self.emit(insn)
 
     def handle_operation(self, insn):
@@ -529,5 +555,5 @@ def handle_operation(self, insn):
             self.emit(insn)
 
     def handle_unary_operation(self, insn):
-        self.slot_value_map = {}
+        self.clear()
         self.emit(insn)

compiler_main.py

@@ -91,9 +91,13 @@ def __iter__(self):
         writer = DummyWriter()
     writer.open()
 
+    page_size = args.page_size
+    # don't bother with memory if not used
+    if not assembler.use_mem:
+        page_size = 0
     session = CompilerSession((x, y, z), writer, args.namespace, stack_size=args.stack,
                       args=sargs, setup_on_load=args.setup_on_load, debug=args.debug,
-                      page_size=args.page_size)
+                      page_size=page_size)
     assembler.write_to_session(session)
     setup, cleanup = session.create_up_down_functions(args.spawn_location)
     writer.close()

session.py

@@ -126,6 +126,10 @@ def Tracked(command):
         current_push_func = 'stack_push_0'
         current_pop_func = 'stack_pop_0'
         self.scope.add_function_names((current_push_func, current_pop_func))
+        stack_overflow = Execute.If(SelEquals(Var('success_tracker'), 0),
+                                    Tellraw(['Stack overflow error!'], 'a'))
+        stack_underflow = Execute.If(SelEquals(Var('success_tracker'), 0),
+                                     Tellraw(['Stack underflow error!'], 'a'))
         for i in range(self.stack_size):
             stack_dump.append(Var('stack_slot', i))
             if i != self.stack_size - 1:
@@ -152,12 +156,16 @@ def Tracked(command):
                     current_push_seq = Subsequence()
                     current_pop_seq = Subsequence()
                 else:
+                    current_push_seq.add_command(stack_overflow)
+                    current_pop_seq.add_command(stack_overflow)
                     self.add_subsequence(current_push_func, current_push_seq)
                     self.add_subsequence(current_pop_func, current_pop_seq)
                 current_push_func = next_push_func
                 current_pop_func = next_pop_func
 
         if one_function:
+            current_push_seq.add_command(stack_overflow)
+            current_pop_seq.add_command(stack_overflow)
             self.add_subsequence(current_push_func, push_stack)
             self.add_subsequence(current_pop_func, pop_stack)