Going crazy

Ram Rachum · Ram Rachum · commit a2ddd527619c · 2009-08-15T12:07:18.000+02:00
diff --git a/src/garlicsim/crunchers/__init__.py b/src/garlicsim/crunchers/__init__.py
@@ -0,0 +1,2 @@
+from cruncherthread import *
+from cruncherprocess import *
diff --git a/src/garlicsim/crunchers/cruncherprocess.py b/src/garlicsim/crunchers/cruncherprocess.py
@@ -0,0 +1,115 @@
+"""
+
+todo: What if EdgeRenderer has a run-time error?
+
+
+todo: In the future, we may want the EdgeCruncher to receive a
+copy of the SimulationCore object. We will have to implement
+a copy() method on SimulationCore and pass it on to the new process.
+
+
+todo maybe: put something on edgecruncher that will shut it off
+if the main program is killed
+
+todo maybe: process creation is sometimes slow on windows.
+maybe have a spare EdgeCruncher at all times?
+
+todo maybe: instead of passing the starter state as a parameter,
+it should be sent in a queue.
+
+todo: make sure the cursor does not get an hourglass when it shouldn't
+
+todo: Smarter priority setting. Besides, obviously, supporting Linux,
+Mac OS, etc., we need to monitor how much de-facto priority the
+process is actually getting from the OS, and to tweak its "official"
+priority accordingly.
+
+todo: it seems that on one-core systems the crunching is very slow.
+Maybe due to very low process priority of edgecruncher.
+
+
+"""
+
+
+import multiprocessing
+
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+
+try:
+    from garlicsim.misc.processpriority import set_process_priority
+except:
+    pass
+
+class CruncherProcess(multiprocessing.Process):
+    """
+    EdgeCruncher is a subclass of multiprocessing.Process. An EdgeCruncher
+    is responsible for crunching the simulation in the background.
+    An EdgeCruncher gets its instruction from the method `Project.sync_workers`.
+
+    How does the EdgeCruncher work? Essentially, it gets sent a state from
+    sync_workers. It then starts repeatedly stepping from this state, and puts
+    all the resulting states in a queue. An EdgeCruncher is quite dumb actually,
+    most of the smart work is being done by sync_workers.
+    """
+    def __init__(self,starter,step_function,*args,**kwargs):
+        multiprocessing.Process.__init__(self,*args,**kwargs)
+
+        self.step=step_function
+        self.starter=starter
+        self.daemon=True
+
+        self.work_queue=multiprocessing.Queue()
+        """
+        The EdgeCruncher puts the work that it has completed
+        into this queue, to be picked up by sync_workers.
+        """
+
+        self.message_queue=multiprocessing.Queue()
+        """
+        This queue is used by sync_workers to send instructions
+        to the EdgeRenderer.
+        """
+
+
+    def set_priority(self,priority):
+        """
+        Sets the priority of this process: Currently Windows only.
+        """
+        assert priority in [0,1,2,3,4,5]
+        set_process_priority(self.pid,priority)
+
+    def run(self):
+        """
+        The function ran by EdgeCruncher. Does the actual work.
+        """
+
+        try:
+            self.set_priority(0)
+        except:
+            pass
+
+        #import psyco #These two belong here?
+        #psyco.full()
+
+        current = self.starter
+        order = None
+        while True:
+            next = self.step(current)
+            self.work_queue.put(next)
+            current = next
+
+            try:
+                order=self.message_queue.get(block=False)
+                #do something with order
+                if order=="Terminate":
+                    return
+                order = None
+            except queue.Empty:
+                pass
+
+    def terminate(self):
+        self.message_queue.put("Terminate")
+
diff --git a/src/garlicsim/crunchers/cruncherthread.py b/src/garlicsim/crunchers/cruncherthread.py
@@ -31,7 +31,6 @@
 """
 
 
-#from core import *
 import threading
 
 try:
@@ -44,7 +43,7 @@
 except:
     pass
 
-class EdgeCruncher(threading.Thread):
+class CruncherThread(threading.Thread):
     """
     EdgeCruncher is a subclass of multiprocessing.Process. An EdgeCruncher
     is responsible for crunching the simulation in the background.
diff --git a/src/garlicsim/project.py b/src/garlicsim/project.py
@@ -17,8 +17,9 @@
 
 """
 
+import random
 import state
-from edgecruncher import EdgeCruncher
+from crunchers import CruncherThread, CruncherProcess
 from misc.dumpqueue import dump_queue
 from misc.infinity import Infinity # Same as Infinity=float("inf")
 
@@ -45,7 +46,7 @@ class Project(object):
 
     def __init__(self,simulation_package):
 
-        self.simulation_package=simulation_package
+        self.init_simulation_package(simulation_package)
         self.tree=state.Tree()
 
         self.workers={}
@@ -59,6 +60,19 @@ def __init__(self,simulation_package):
         how many nodes should be created after them.
         """
 
+    def init_simulation_package(self, simulation_package):
+
+        self.simulation_package = simulation_package
+
+        step_defined = hasattr(simulation_package, "step")
+        history_step_defined = hasattr(simulation_package, "history_step")
+
+        if step_defined and history_step_defined:
+            raise StandardError("The simulation package is defining both a\
+                                 step and a history_step - That's forbidden!")
+
+        self.history_looker = history_step_defined
+
 
     def make_plain_root(self,*args,**kwargs):
         """
@@ -138,6 +152,8 @@ def sync_workers(self,temp_infinity_node=None):
         Returns the total amount of nodes that were added to the tree.
         """
 
+        Cruncher = random.choice([CruncherThread, CruncherProcess])
+
         my_edges_to_crunch=self.edges_to_crunch.copy()
 
         if temp_infinity_node!=None:
@@ -208,7 +224,7 @@ def sync_workers(self,temp_infinity_node=None):
             else:
                 # Create worker
                 if edge.still_in_editing==False:
-                    worker=self.workers[edge]=EdgeCruncher(edge.state,step_function=self.simulation_package.step)
+                    worker=self.workers[edge]=Cruncher(edge.state,step_function=self.simulation_package.step)
                     worker.start()
                 if edge==temp_infinity_node:
                     continuation_of_temp_infinity_node=edge
diff --git a/src/garlicsimwx/misc/threadtimer.py b/src/garlicsimwx/misc/threadtimer.py
@@ -21,9 +21,16 @@ def stop(self):
        self.alive = False
 
 class Thread(threading.Thread):
+
     def run(self):
-       while self.parent.alive:
-           time.sleep(self.parent.interval / 1000.0)
+
+        interval_in_seconds = self.parent.interval / 1000.0
+        def sleep():
+            time.sleep(interval_in_seconds)
+
+        sleep()
+        while self.parent.alive:
            event = wx.PyEvent()
            event.SetEventType(wxEVT_THREAD_TIMER)
-           wx.PostEvent(self.parent.parent, event)
+           wx.PostEvent(self.parent.parent, event)
+           sleep()
diff --git a/src/garlicsimwx/simulationpackages/historytest/__init__.py b/src/garlicsimwx/simulationpackages/historytest/__init__.py
@@ -0,0 +1,11 @@
+from historytest import *
+
+wx_installed=False
+try:
+    import wx
+    wx_installed=True
+except ImportError:
+    pass
+
+if wx_installed:
+    from historytestgui import *
diff --git a/src/garlicsimwx/simulationpackages/historytest/historytest.py b/src/garlicsimwx/simulationpackages/historytest/historytest.py
@@ -0,0 +1,35 @@
+import garlicsim.state
+import copy
+#from garlicsim.misc.myprint import my_print
+
+import random
+random.seed()
+
+def make_plain_state(*args,**kwargs):
+    state=garlicsim.state.State()
+    state._State__touched=True
+    state.number=0
+    return state
+
+
+def make_random_state(*args,**kwargs):
+    state=garlicsim.state.State()
+    state._State__touched=True
+    state.number=random.randint(0,10)
+    return state
+
+
+def step(history_browser,*args,**kwargs):
+
+    new_state=garlicsim.state.State()
+
+    with history_browser:
+        root=history_browser.request_state_by_number(0)
+
+    if random.choice([True,False]):
+        new_state.number=root.number
+    else:
+        new_state.number=888
+    return new_state
+
+step.history_looker=True
diff --git a/src/garlicsimwx/simulationpackages/historytest/historytestgui.py b/src/garlicsimwx/simulationpackages/historytest/historytestgui.py
@@ -0,0 +1,13 @@
+import wx
+
+def initialize(gui_project):
+    gui_project.text_ctrl=wx.TextCtrl(gui_project.state_showing_window,-1,style=wx.TE_MULTILINE)
+    sizer=wx.BoxSizer(wx.VERTICAL)
+    sizer.Add(gui_project.text_ctrl,1,wx.EXPAND)
+    gui_project.state_showing_window.SetSizer(sizer)
+
+
+
+def show_state(gui_project,state):
+    gui_project.text_ctrl.SetValue(str(state.number))
+

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+from cruncherthread import *`
	`2`	`+from cruncherprocess import *`