[pypy-svn] r32849 - pypy/dist/pypy/objspace/constraint/applevel

[auc at codespeak.net]

Author: auc
Date: Tue Oct  3 17:50:42 2006
New Revision: 32849

Modified:
   pypy/dist/pypy/objspace/constraint/applevel/solver.py
Log:
recomputation might work now


Modified: pypy/dist/pypy/objspace/constraint/applevel/solver.py
==============================================================================
--- pypy/dist/pypy/objspace/constraint/applevel/solver.py	(original)
+++ pypy/dist/pypy/objspace/constraint/applevel/solver.py	Tue Oct  3 17:50:42 2006
@@ -44,60 +44,40 @@
 
 #-- dfs with recomputations
 
-class Chain(object):
-    def __init__(self, space=None, parent=None, distance=1):
-        self.space = space
-        self.parent = parent
-        self.distance = distance
-        self.child = None
-        self.last_branch = None
-    def set_branches(self, branches):
-        self.branches = range(branches)
-    def collect_space(self, space):
-        self.child = Chain(space, parent=self,
-                           distance=self.distance + 1)
-        return self.child
-    def clone_time(self):
-        return self.distance % recomputation_distance
-
-def dfs_with_recomputations(space, recomputation_distance=1):
-    assert recomputation_distance > 0
-
-    node = Chain(space)
-
-    def get_space():
-        # XXX: write me
-        pass
-        
-    while node:
-        space = get_space()
-        status = space.ask()
-        if status == 1:
-            yield space.merge()
-        elif status > 1:
-            if node.clone_time():
-                clone = space.clone()
-                if node.child is None:
-                    node.set_branges(status)
-                branch = node.branches.pop()
-                node.last_branch = branch # recomputation info
-                node = node.collect(clone)
-                clone.commit(branch)
-            else:
-                #find previous clone_time node
-                cur = node.parent
-                while not cur.clone_time():
-                    cur = cur.parent
-                # take a clone of the local space,
-                # replay all the branches
-                clone = cur.space.clone()
-                while cur.child:
-                    clone.commit(cur.last_branch)
-                    cur = cur.child
-                # now, do the new computation
-                # XXX: factor me out
-                assert cur is node
-                branch = node.branches.pop()
-                node.last_branch = branch
-                node = node.collect(None)
-                clone.commit(branch)
+
+def recompute(space, branches_list):
+    # branches_list contains the recomputation path,
+    # bottom-up
+    if branches_list == None:
+        return space.clone()
+    else:
+        head, tail = branches_list
+        C = recompute(space, tail)
+        return C.commit(head)
+
+def dfre(S, R, branches_list, distance, max_dist, solutions):
+    status = S.ask()
+    if status == 0:
+        return
+    elif status == 1:
+        solutions.append(S.merge())
+        return
+    else: # assert status == 2
+        if distance == max_dist:
+            C = S.clone()
+            S.commit(1)
+            dfre(S, C, (1, None), 1, max_dist, solutions)
+            C.commit(2)
+            dfre(C, C, None, max_dist, max_dist, solutions)
+        else:
+            S.commit(1)
+            dfre(S, R, (1, branches_list), distance+1, max_dist, solutions)
+            C = recompute(R, branches_list)
+            C.commit(2)
+            dfre(C, R, (2, branches_list), distance+1, max_dist, solutions)
+
+def solve_recomputing(space, recomputation_distance=5):
+    solutions = []
+    dfre(space, space, None, recomputation_distance, max_dist, solutions)
+    return solutions
+