Merge branch 'fix/timing' into 'master'

save execution time on futures inside runners

See merge request qt/adaptive!130

Author: basnijholt

adaptive/runner.py

@@ -11,7 +11,6 @@
 import abc
 
 from .notebook_integration import live_plot, live_info, in_ipynb
-from .utils import timed
 
 try:
     import ipyparallel
@@ -105,8 +104,7 @@ class BaseRunner(metaclass=abc.ABCMeta):
     Methods
     -------
     overhead : callable
-        The overhead in percent of using Adaptive. This includes the
-        overhead of the executor. Essentially, this is
+        The overhead in percent of using Adaptive. Essentially, this is
         ``100 * (1 - total_elapsed_function_time / self.elapsed_time())``.
 
     """
@@ -130,8 +128,7 @@ def __init__(self, learner, goal, *,
         self.learner = learner
         self.log = [] if log else None
 
-        # Function timing
-        self.function = functools.partial(timed, self.learner.function)
+        # Timing
         self.start_time = time.time()
         self.end_time = None
         self._elapsed_function_time = 0
@@ -190,7 +187,8 @@ def _process_futures(self, done_futs):
         for fut in done_futs:
             x = self.pending_points.pop(fut)
             try:
-                y, t = fut.result()
+                y = fut.result()
+                t = time.time() - fut.start_time  # total execution time
             except Exception as e:
                 self.tracebacks[x] = traceback.format_exc()
                 self.to_retry[x] = self.to_retry.get(x, 0) + 1
@@ -218,7 +216,9 @@ def _get_futures(self):
         points, _ = self._ask(n_new_tasks)
 
         for x in points:
-            self.pending_points[self._submit(x)] = x
+            fut = self._submit(x)
+            fut.start_time = time.time()  # so we can measure execution time
+            self.pending_points[fut] = x
 
         # Collect and results and add them to the learner
         futures = list(self.pending_points.keys())
@@ -332,7 +332,7 @@ def __init__(self, learner, goal, *,
         self._run()
 
     def _submit(self, x):
-        return self.executor.submit(self.function, x)
+        return self.executor.submit(self.learner.function, x)
 
     def _run(self):
         first_completed = concurrent.FIRST_COMPLETED
@@ -471,9 +471,9 @@ def goal(_):
     def _submit(self, x):
         ioloop = self.ioloop
         if inspect.iscoroutinefunction(self.learner.function):
-            return ioloop.create_task(self.function(x))
+            return ioloop.create_task(self.learner.function(x))
         else:
-            return ioloop.run_in_executor(self.executor, self.function, x)
+            return ioloop.run_in_executor(self.executor, self.learner.function, x)
 
     def status(self):
         """Return the runner status as a string.

adaptive/tests/test_runner.py

@@ -2,11 +2,39 @@
 
 import asyncio
 
-from ..learner import Learner2D
+import pytest
+
+from ..learner import Learner1D, Learner2D
 from ..runner import simple, BlockingRunner, AsyncRunner, SequentialExecutor
 
 
-def test_nonconforming_output():
+def blocking_runner(learner, goal):
+    BlockingRunner(learner, goal, executor=SequentialExecutor())
+
+
+def async_runner(learner, goal):
+    runner = AsyncRunner(learner, goal, executor=SequentialExecutor())
+    asyncio.get_event_loop().run_until_complete(runner.task)
+
+
+runners = [simple, blocking_runner, async_runner]
+
+def trivial_goal(learner):
+    return learner.npoints > 10
+
+@pytest.mark.parametrize('runner', runners)
+def test_simple(runner):
+    """Test that the runners actually run."""
+
+    def f(x):
+        return x
+    learner = Learner1D(f, (-1, 1))
+    runner(learner, lambda l: l.npoints > 10)
+    assert len(learner.data) > 10
+
+
+@pytest.mark.parametrize('runner', runners)
+def test_nonconforming_output(runner):
     """Test that using a runner works with a 2D learner, even when the
     learned function outputs a 1-vector. This tests against the regression
     flagged in https://gitlab.kwant-project.org/qt/adaptive/issues/58.
@@ -15,15 +43,14 @@ def test_nonconforming_output():
     def f(x):
         return [0]
 
-    def goal(l):
-        return l.npoints > 10
+    runner(Learner2D(f, [(-1, 1), (-1, 1)]), trivial_goal)
 
-    learner = Learner2D(f, [(-1, 1), (-1, 1)])
-    simple(learner, goal)
 
-    learner = Learner2D(f, [(-1, 1), (-1, 1)])
-    BlockingRunner(learner, goal, executor=SequentialExecutor())
+def test_aync_def_function():
 
-    learner = Learner2D(f, [(-1, 1), (-1, 1)])
-    runner = AsyncRunner(learner, goal, executor=SequentialExecutor())
+    async def f(x):
+        return x
+
+    learner = Learner1D(f, (-1, 1))
+    runner = AsyncRunner(learner, trivial_goal)
     asyncio.get_event_loop().run_until_complete(runner.task)

adaptive/utils.py

@@ -8,12 +8,6 @@
 import time
 
 
-def timed(f, *args, **kwargs):
-    t_start = time.time()
-    result = f(*args, **kwargs)
-    return result, time.time() - t_start
-
-
 def named_product(**items):
     names = items.keys()
     vals = items.values()