changeset 1215:f2fce145b9e1

Remove unused increment_pc decorator.
author Martin Geisler <mg@cs.au.dk>
date Fri, 18 Sep 2009 15:48:52 +0200
parents 34a7d23462a7
children d325a4ee6625
files doc/program-counters.txt doc/runtime.txt viff/runtime.py
diffstat 3 files changed, 27 insertions(+), 72 deletions(-) [+]
line wrap: on
line diff
--- a/doc/program-counters.txt	Fri Sep 18 14:43:01 2009 +0200
+++ b/doc/program-counters.txt	Fri Sep 18 15:48:52 2009 +0200
@@ -88,63 +88,41 @@
 point in the execution tree. The execution tree is never explicitly
 constructed in VIFF, so a simple static numbering is not possible.
 
-Instead we mark methods that need to increment the program counter
-with the :func:`viff.runtime.increment_pc` decorator. The program
-counter starts at the value ``[0]`` and the decorated method will now
-begin by doing::
+The program counter starts at the value ``[0]``. It is changed in two
+cases:
 
-  self.program_counter[-1] += 1
-  self.program_counter.append(0)
+* when a callback is scheduled using
+  :meth:`viff.runtime.BasicRuntime.schedule_callback`, a new
+  sub-program counter is allocated. A sub-program counter is simply a
+  program counter with another digit. Because of the asynchronous
+  network, the callback will be invoked at an unknown later time. When
+  invoked, it sees the sub-program counter. This ensures that that the
+  parties agree on any network traffic produced in the callback.
 
-before it executes its body. When the body is finished, the method
-does::
+  When a piece of code like this::
 
-  self.program_counter.pop()
+    def cb(ignored):
+        print "callback:", self.program_counter
+    d = Deferred()
 
-before it returns. A method :meth:`foo` defined like this::
+    print "main:", self.program_counter
+    self.schedule_callback(d, cb)
+    print "main:", self.program_counter
 
-  @increment_pc
-  def foo(self):
-      print "foo:", self.program_counter
+    d.callback(None)
 
-is thus turned into this::
+  is executed, one will see output like this:
 
-  def foo(self):
-      self.program_counter[-1] += 1
-      self.program_counter.append(0)
-      print "foo:", self.program_counter
-      self.program_counter.pop()
+  .. code-block:: none
 
-and when executed starting from the initial program counter of ``[0]``
-we see that it prints ``foo: [1, 0]`` and leaves the program counter
-at ``[1]`` after it returns. It is very important that the program
-counter is left changed like this, for this means that the next call
-to :meth:`foo` will print ``foo: [2, 0]`` and increment the program
-counter to ``[2]``.
+     main: [0]
+     main: [1]
+     callback: [0, 0]
 
-If we have a method :meth:`bar` which calls :meth:`foo` several times::
+* some functions depend on a unique program counter. These functions
+  simply increase the last digit in the current program counter::
 
-  @increment_pc
-  def bar(self):
-      print "bar:", self.program_counter
-      self.foo()
-      print "bar:", self.program_counter
-      self.foo()
-      print "bar:", self.program_counter
-
-then the result of calling :meth:`bar` will be:
-
-.. code-block:: none
-
-   bar: [1, 0]
-   foo: [1, 1, 0]
-   bar: [1, 1]
-   foo: [1, 2, 0]
-   bar: [1, 2]
-
-Notice how each sub-call adds another digit to the counter and how it
-increments the counter used at the level of the caller. This system
-ensures that all program counters are unique.
+    self.program_counter[-1] += 1
 
 
 Alternatives
--- a/doc/runtime.txt	Fri Sep 18 14:43:01 2009 +0200
+++ b/doc/runtime.txt	Fri Sep 18 15:48:52 2009 +0200
@@ -31,8 +31,6 @@
       and other messages. They serve to distinguish messages sent with
       the same program counter from one another.
 
-   .. autofunction:: increment_pc
-
    .. autofunction:: preprocess
 
       See also :ref:`preprocessing` for more background information.
@@ -88,9 +86,7 @@
          different parts of the program execution never reuses the
          same program counter for different variables.
 
-         The :func:`increment_pc` decorator is responsible for
-         dynamically building the tree as the execution unfolds and
-         :meth:`schedule_callback` is responsible for scheduling
-         callbacks with the correct program counter.
+         The :meth:`schedule_callback` method is responsible for
+         scheduling callbacks with the correct program counter.
 
          See :ref:`program-counters` for more background information.
--- a/viff/runtime.py	Fri Sep 18 14:43:01 2009 +0200
+++ b/viff/runtime.py	Fri Sep 18 15:48:52 2009 +0200
@@ -401,25 +401,6 @@
         reason.trap(ConnectionDone)
 
 
-def increment_pc(method):
-    """Make *method* automatically increment the program counter.
-
-    Adding this decorator to a :class:`Runtime` method will ensure
-    that the program counter is incremented correctly when entering
-    the method.
-    """
-
-    @wrapper(method)
-    def inc_pc_wrapper(self, *args, **kwargs):
-        try:
-            self.program_counter[-1] += 1
-            self.program_counter.append(0)
-            return method(self, *args, **kwargs)
-        finally:
-            self.program_counter.pop()
-    return inc_pc_wrapper
-
-
 def preprocess(generator):
     """Track calls to this method.