Use binary search to find memory slot. A few fixes to the compiler.

Author: simon816

compiler/asm_extensions.py

@@ -15,29 +15,89 @@ def __init__(self, pos, writer, namespace, page_size=64, **kwargs):
         self.add_page()
 
     def add_page(self):
-        setter = Subsequence()
-        getter = Subsequence()
-        dump = ["["]
-
         mbr = Var('memory_buffer')
         mar = Var('memory_address')
 
-        for i in range(self.page_size):
-            slot = Var('memory_slot', i)
-            dump.append(slot)
-            if i != self.page_size - 1:
-                dump.append(",")
+        def pair_name(fn, pair):
+            return 'memory/%s_%d_%d' % (fn, pair.min, pair.max)
 
-            setter.add_command(OpAssign(slot, mbr).where(SelEquals(mar, i)))
-            getter.add_command(OpAssign(mbr, slot).where(SelEquals(mar, i)))
+        def create_function(pair, force=False):
+            getter = Subsequence()
+            setter = Subsequence()
+            def gen_fn(fn, p):
+                return Function(pair_name(fn, p), cond_type='if',
+                                cond=SelRange(mar, min=p.min, max=p.max))
+            def gen_assign(n, g=True):
+                slot = Var('memory_slot', n)
+                return OpAssign(mbr if g else slot, slot if g else mbr) \
+                                .where(SelEquals(mar, n))
 
-        self.scope.add_function_names(('mem_set', 'mem_get', 'mem_dump'))
-        self.add_subsequence('mem_set', setter)
+            if pair.left and pair.left.left:
+                getter.add_command(gen_fn('mem_get', pair.left))
+                setter.add_command(gen_fn('mem_set', pair.left))
+            if pair.right and pair.right.right:
+                getter.add_command(gen_fn('mem_get', pair.right))
+                setter.add_command(gen_fn('mem_set', pair.right))
+
+            if not pair.left and not pair.right and not force:
+                # Don't do anything here, it's done in the next level up
+                return
+
+            if pair.left and not pair.left.left or force:
+                getter.add_command(gen_assign(pair.min))
+                setter.add_command(gen_assign(pair.min, False))
+            if pair.right and not pair.right.right:
+                getter.add_command(gen_assign(pair.max))
+                setter.add_command(gen_assign(pair.max, False))
+
+            name_get = pair_name('mem_get', pair)
+            name_set = pair_name('mem_set', pair)
+            self.scope.add_function_names((name_get, name_set))
+            self.add_subsequence(name_get, getter)
+            self.add_subsequence(name_set, setter)
+
+        entry_point = self.generate_bin_tree(self.page_size, create_function)
+        if not entry_point.left and not entry_point.right:
+            create_function(entry_point, force=True)
+
+        # Redirect mem_get and mem_set to the actual entry point
+        getter = Subsequence()
+        setter = Subsequence()
+        getter.add_command(Function(pair_name('mem_get', entry_point)))
+        setter.add_command(Function(pair_name('mem_set', entry_point)))
+        self.scope.add_function_names(('mem_get', 'mem_set'))
         self.add_subsequence('mem_get', getter)
-        s = Subsequence()
-        dump.append("]")
-        s.add_command(Tellraw(dump, 'a'))
-        self.add_subsequence('mem_dump', s)
+        self.add_subsequence('mem_set', setter)
+
+
+    def generate_bin_tree(self, size, callback):
+        assert size > 0
+        from collections import namedtuple
+        Pair = namedtuple('Pair', 'left right min max')
+        old_pairs = []
+        for n in range(size):
+            pair = Pair(None, None, n, n)
+            old_pairs.append(pair)
+            callback(pair)
+        while len(old_pairs) > 1:
+            pairs = []
+            waiting = None
+            for pair in old_pairs:
+                if waiting is None:
+                    waiting = pair
+                else:
+                    new_pair = Pair(waiting, pair, waiting.min, pair.max)
+                    pairs.append(new_pair)
+                    callback(new_pair)
+                    waiting = None
+
+            if waiting is not None:
+                # Dangling node, occurs if size is not a power of 2
+                pairs.append(waiting)
+                callback(waiting)
+
+            old_pairs = pairs
+        return old_pairs[0]
 
     def extended_setup(self, up, down):
         for i in range(self.page_size):