Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP

Loading…

add sugar methods/properties to AsyncResult #1548

Merged
merged 8 commits into from

2 participants

@minrk
Owner

Adds the following attributes / methods:

  • ar.wall_time = received - submitted
  • ar.serial_time = sum of serial computation time
  • ar.elapsed = time since submission (wall_time if done)
  • ar.progress = (int) number of sub-tasks that have completed
  • len(ar) = # of tasks
  • ar.wait_interactive(): prints progress

These are simple methods derived from the metadata/timestamps already created. But I've been persuaded by @wesm's practice of including simple methods that do useful (and/or cool) things.

This also required/revealed some minor fixes/cleanup to clear_output in some cases:

  • dedent base core.displaypub.clear_output, so it's actually defined in the class
  • clear_output publishes '\r\b', so it will clear terminal-like frontends that don't understand full clear_output behavior.
  • core.display.clear_output() still works, even outside an IPython session.
@minrk
Owner

At @fperez request, I had a go at addressing the flicker when using clear_output in the notebook. I used a simple timeout, which gets cleared/flushed immediately on the next output-related action.

I won't object to moving that to a separate PR, but I did it here as it is related, and this new code makes significant use of the clear;print;repeat pattern for which the flicker is most problematic.

@minrk
Owner

this notebook shows a few examples of print, the new AR.wait_interactive, and plotting with clear_output, all of which seem better behaved than previously.

@minrk minrk referenced this pull request
Merged

clear_output improvements #1563

@minrk
Owner

This PR now depends on PR #1563

@fperez
Owner

@minrk, I merged #1563 but now it's producing some conflicts. Could you rebase this one? I'll be happy to review it quickly...

@fperez
Owner

And as I commented in that other one, might as well make the notebook with examples part of the PR, so we beef up the notebooks we provide with the system for users. That will become even more useful once we start including their html for in the docs, along with a link to the original .ipynb file, as we'll be able to point users to those pages in the docs.

@minrk minrk add sugar methods/properties to AsyncResult
* ar.wall_time = received - submitted
* ar.serial_time = sum of serial computation time
* ar.elapsed = time since submission (wall_time if done)
* ar.progress = (int) number of sub-tasks that have completed
* ar.wait_interactive(): prints progress
* len(ar) = # of tasks
148c775
@minrk
Owner

rebased - I'll add the notebook in the morning, probably.

@minrk
Owner

Progress notebook added, demos:

  • clear_output/print/flush
  • AsyncResult.wait_interactive
  • clear_output/display(Figure)
  • HTML/JS progress bar
  • PyMC ProgressBar class
docs/examples/notebooks/Progress.ipynb
((19 lines not shown))
+ "What the notebook *does* support is explicit `clear_output`, and you can use this to replace previous",
+ "output (specifying stdout/stderr or the special IPython display outputs)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "A simple example printing our progress iterating through a list:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "from IPython.core.display import clear_output",
+ "for i in range(10):",
@fperez Owner
fperez added a note

It's missing an import time here.

@minrk Owner
minrk added a note

ah, yes. I have import os,sys,time in my startup files, so I always forget to import them.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
docs/examples/notebooks/Progress.ipynb
((76 lines not shown))
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "%pylab inline"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 6
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "from scipy.special import jn",
@fperez Owner
fperez added a note

I'd rewrite this cell as:

from scipy.special import jn
x = linspace(0,5)
f, ax = plt.subplots()
ax.set_title("Bessel functions")

for n in range(1,10):
    time.sleep(1)
    ax.plot(x, jn(x,n))
    clear_output()
    display(f)

# close the figure at the end, so we don't get a duplicate
# of the last plot
plt.close()

It's a bit cleaner api-wise regarding matplotlib, and it completely eliminates the flicker. The trick is to do all plotting with the axis object, which doesn't force a draw call. Then, we can do clear_output right before the display call, and most likely (unless it's a super-complex plot), it will finish before any flickering happens.

You can mention this and update the comment below accordingly, indicating how this will eliminate completely all flickering in most common cases (though it can still appear for sufficiently complex plots).

@minrk Owner
minrk added a note

Thanks, I made this change, though it isn't true that it eliminates the flicker. Actually eliminating flicker will require changing how clear_output works in a more complicated way (don't resize height until after new content is drawn), because as it is now, it's still resizing to zero immediately before drawing the image, which takes more than zero time (though it is very quick).

@minrk Owner
minrk added a note

Hm, nevermind - the flicker does seem to be gone. That means that I misunderstood what was causing the flicker, and also suggests that calls to plot() results in some IOPub message, possibly an empty sys.stdout.flush()?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
docs/examples/notebooks/Progress.ipynb
@@ -0,0 +1,226 @@
+{
+ "metadata": {
+ "name": "Progress"
+ },
+ "nbformat": 3,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Progress bars and clear_output",
@fperez Owner
fperez added a note

Perhaps change the title to 'Simple animations, progress bars and output area cleaning'? I'd also suggest renaming the file to something slightly more descriptive, say animations_progress_bars or similar (casing up to you). 'Progress' by itself as filename is a bit cryptic.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
@fperez fperez commented on the diff
IPython/parallel/client/asyncresult.py
@@ -255,7 +259,76 @@ def __iter__(self):
# already done
for r in rlist:
yield r
-
+
+ def __len__(self):
+ return len(self.msg_ids)
+
+ #-------------------------------------
+ # Sugar methods and attributes
@fperez Owner
fperez added a note

This is fantastic, and the implementation looks great. I just think it needs mentioning somewhere in the docs, though... Otherwise users are never going to find out about these things. It could be just a paragraph pointing out their existence, but I think we do need something in the docs about these guys.

@minrk Owner
minrk added a note

I've been a bit reluctant to add things to the current docs, because I really want to trash them entirely and start from scratch, but obviously I should document new features as they are added.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
@fperez
Owner

Minor comments inline, easy to fix up and we'll be good to go. This is awesome.

@minrk minrk add Animations and Progress example notebook
demos intermediate progress with:

* clear_output/print/flush
* AsyncResult.wait_interactive
* clear_output/display(Figure)
* HTML/JS progress bar
* PyMC ProgressBar class
f5e3cc0
@minrk
Owner

I made your edits to the notebook, and started a doc for the AsyncResult object. I really want to make it clear that the AsyncResult object itself is where most of our API lives. At least the nifty parts.

I have one question we should resolve before merging. In wall_time, I use received - submitted, which is the actual roundtrip time for the Client. The only problem with this one is that the received timestamp is not especially reliable, particularly in interactive use cases. The reason being that this timestamp is made when the result is pulled off of the queue in the Client, as a result of Client.spin(). So if the result of the computation arrives either while the user is sitting idle at an interactive prompt or just performing some client-side computation, that time is added to the wall_time measure.

This is a larger issue for AsyncHubResults (those fetched from the Hub), where the received stamp could technically be days after the computation finished.

Possible partial solutions to this problem:

  • HubResults should use completed-submitted, ignoring result-reply overhead
  • all AsyncResults should use completed-submitted (most consistent, but probably not most useful/interesting)
  • HubResults should just not have a wall_time property
  • Add an analogue to received to the Hub's DB, and use that in HubResults
  • Leave it as-is, and let users deal with wall_time rarely being useful in HubResults (it would still be accurate if the HubResult is requested and waited upon while the computation is pending)

I'm personally inclined towards either one of the last two, but I want there to be a convenient

There are a couple of other timings that might be useful to add:

  • last completed - first started (actual time spent working, excluding overhead - I don't know what it's name should be)
  • last completed - first submitted (wall_time excluding reply overhead, which may not be interesting or meaningful)
  • last received - first started (excludes start overhead, which could have just been waiting for other jobs in the queue)
  • idle time (total time spent on each engine not during a computation) - this might be computed per-engine to draw one of those pipeline concurrency figures.

I don't know how many of these I should actually include. Perhaps I should just make a method that makes it easy to do any of the last/first X - first/last Y deltas.

@fperez

Ouch, no... Let's avoid filenames with spaces in them in the repo, they always end up causing trouble for automated handling. I know the underscores look ugly in files that are much more 'gui' oriented, but spaces in filenames really are a timebomb waiting to happen for scripted work.

Owner

Seriously? The notebook is a GUI tool, and GUI files should have reasonable names. Underscores are a gross hack to appease pathetic tools.

Owner

But managing directories with filenames that have spaces in them with automated tools is extraordinarily error prone. I don't want to end up having to debug one day a script for doc generation (for example) because something downstream choked on a space. I've been bitten by that particular problem enough times in my life that I simply don't want to waste my time with that kind of problem. Practicality beats purity, in this case...

Owner

I don't agree at all, and have much less patience or sympathy for shitty tools, but I will make the change.

I would think that handling simple sensible filenames is a reasonable expectation in this century.

Owner

If you really feel strongly about it, leave it as-is. If we ever run into problems I'll just rename things outright; I'm not trying to upset you over a minor change, just trying to avoid possible annoyances down the road.

Owner

It's not a big deal - I just get annoyed at how bad command-line tools are sometimes, and how *ix standard practices like this one tend to be based on how these tools suck at basic functionality.

I do think that if this is to be standard practice in the notebook, then we should proabably unescape underscores, and draw regular spaces in the notebook list. A listing full of underscores that are really spaces is pretty ugly, and simply doesn't fit in with the web today, where spaces are handled frequently and without issue.

minrk added some commits
@minrk minrk add 'received' timestamp to DB
allows 'wall_time' to make sense in cases other than simple waiting AsyncResult.
bd8a8ec
@minrk minrk add AsyncResult.timedelta
for computing various comparisons of timestamps in AsyncResults
d004201
@minrk minrk remove spaces in progress notebook filename
appease crappy tools that can't deal with reasonable filenames.
978ac5b
@minrk minrk test new AsyncResult properties 66cc8f8
@minrk minrk document new AsyncResult properties 89a00db
@minrk
Owner

Okay, review addressed I think:

  • spaces removed from filename
  • new properties documented
  • some basic tests added
  • I went with adding received to the Hub's DB for resolving the wall_time issue for HubResults
  • I added AsyncResult.timedelta() for comparing a pair of timestamp sets, which is used in AR.wall_time.

Did I miss anything else?

@fperez

awesome, thanks for all these tests!

@fperez

And this is also great.

@minrk minrk add Client.spin_thread()
runs Client.spin() in a background thread at a set interval
472cd24
@minrk
Owner

Added Client.spin_thread(interval) / stop_spin_thread() for running spin in a background thread, to keep zmq queue clear.

@fperez
Owner

Great, merging now. Awesome job, thanks!

@fperez fperez merged commit e0b4311 into from
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Commits on Apr 14, 2012
  1. @minrk

    add sugar methods/properties to AsyncResult

    minrk authored
    * ar.wall_time = received - submitted
    * ar.serial_time = sum of serial computation time
    * ar.elapsed = time since submission (wall_time if done)
    * ar.progress = (int) number of sub-tasks that have completed
    * ar.wait_interactive(): prints progress
    * len(ar) = # of tasks
  2. @minrk

    add Animations and Progress example notebook

    minrk authored
    demos intermediate progress with:
    
    * clear_output/print/flush
    * AsyncResult.wait_interactive
    * clear_output/display(Figure)
    * HTML/JS progress bar
    * PyMC ProgressBar class
  3. @minrk

    add 'received' timestamp to DB

    minrk authored
    allows 'wall_time' to make sense in cases other than simple waiting AsyncResult.
  4. @minrk

    add AsyncResult.timedelta

    minrk authored
    for computing various comparisons of timestamps in AsyncResults
  5. @minrk

    remove spaces in progress notebook filename

    minrk authored
    appease crappy tools that can't deal with reasonable filenames.
  6. @minrk

    test new AsyncResult properties

    minrk authored
  7. @minrk
Commits on Apr 15, 2012
  1. @minrk

    add Client.spin_thread()

    minrk authored
    runs Client.spin() in a background thread at a set interval
This page is out of date. Refresh to see the latest.
View
111 IPython/parallel/client/asyncresult.py
@@ -15,13 +15,17 @@
# Imports
#-----------------------------------------------------------------------------
+import sys
import time
+from datetime import datetime
from zmq import MessageTracker
+from IPython.core.display import clear_output
from IPython.external.decorator import decorator
from IPython.parallel import error
+
#-----------------------------------------------------------------------------
# Classes
#-----------------------------------------------------------------------------
@@ -255,7 +259,112 @@ def __iter__(self):
# already done
for r in rlist:
yield r
-
+
+ def __len__(self):
+ return len(self.msg_ids)
+
+ #-------------------------------------
+ # Sugar methods and attributes
@fperez Owner
fperez added a note

This is fantastic, and the implementation looks great. I just think it needs mentioning somewhere in the docs, though... Otherwise users are never going to find out about these things. It could be just a paragraph pointing out their existence, but I think we do need something in the docs about these guys.

@minrk Owner
minrk added a note

I've been a bit reluctant to add things to the current docs, because I really want to trash them entirely and start from scratch, but obviously I should document new features as they are added.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
+ #-------------------------------------
+
+ def timedelta(self, start, end, start_key=min, end_key=max):
+ """compute the difference between two sets of timestamps
+
+ The default behavior is to use the earliest of the first
+ and the latest of the second list, but this can be changed
+ by passing a different
+
+ Parameters
+ ----------
+
+ start : one or more datetime objects (e.g. ar.submitted)
+ end : one or more datetime objects (e.g. ar.received)
+ start_key : callable
+ Function to call on `start` to extract the relevant
+ entry [defalt: min]
+ end_key : callable
+ Function to call on `end` to extract the relevant
+ entry [default: max]
+
+ Returns
+ -------
+
+ dt : float
+ The time elapsed (in seconds) between the two selected timestamps.
+ """
+ if not isinstance(start, datetime):
+ # handle single_result AsyncResults, where ar.stamp is single object,
+ # not a list
+ start = start_key(start)
+ if not isinstance(end, datetime):
+ # handle single_result AsyncResults, where ar.stamp is single object,
+ # not a list
+ end = end_key(end)
+ return (end - start).total_seconds()
+
+ @property
+ def progress(self):
+ """the number of tasks which have been completed at this point.
+
+ Fractional progress would be given by 1.0 * ar.progress / len(ar)
+ """
+ self.wait(0)
+ return len(self) - len(set(self.msg_ids).intersection(self._client.outstanding))
+
+ @property
+ def elapsed(self):
+ """elapsed time since initial submission"""
+ if self.ready():
+ return self.wall_time
+
+ now = submitted = datetime.now()
+ for msg_id in self.msg_ids:
+ if msg_id in self._client.metadata:
+ stamp = self._client.metadata[msg_id]['submitted']
+ if stamp and stamp < submitted:
+ submitted = stamp
+ return (now-submitted).total_seconds()
+
+ @property
+ @check_ready
+ def serial_time(self):
+ """serial computation time of a parallel calculation
+
+ Computed as the sum of (completed-started) of each task
+ """
+ t = 0
+ for md in self._metadata:
+ t += (md['completed'] - md['started']).total_seconds()
+ return t
+
+ @property
+ @check_ready
+ def wall_time(self):
+ """actual computation time of a parallel calculation
+
+ Computed as the time between the latest `received` stamp
+ and the earliest `submitted`.
+
+ Only reliable if Client was spinning/waiting when the task finished, because
+ the `received` timestamp is created when a result is pulled off of the zmq queue,
+ which happens as a result of `client.spin()`.
+
+ For similar comparison of other timestamp pairs, check out AsyncResult.timedelta.
+
+ """
+ return self.timedelta(self.submitted, self.received)
+
+ def wait_interactive(self, interval=1., timeout=None):
+ """interactive wait, printing progress at regular intervals"""
+ N = len(self)
+ tic = time.time()
+ while not self.ready() and (timeout is None or time.time() - tic <= timeout):
+ self.wait(interval)
+ clear_output()
+ print "%4i/%i tasks finished after %4i s" % (self.progress, N, self.elapsed),
+ sys.stdout.flush()
+ print
+ print "done"
class AsyncMapResult(AsyncResult):
View
55 IPython/parallel/client/client.py
@@ -18,6 +18,7 @@
import os
import json
import sys
+from threading import Thread, Event
import time
import warnings
from datetime import datetime
@@ -36,7 +37,7 @@
from IPython.utils.localinterfaces import LOCAL_IPS
from IPython.utils.path import get_ipython_dir
from IPython.utils.traitlets import (HasTraits, Integer, Instance, Unicode,
- Dict, List, Bool, Set)
+ Dict, List, Bool, Set, Any)
from IPython.external.decorator import decorator
from IPython.external.ssh import tunnel
@@ -249,6 +250,8 @@ class Client(HasTraits):
metadata = Instance('collections.defaultdict', (Metadata,))
history = List()
debug = Bool(False)
+ _spin_thread = Any()
+ _stop_spinning = Any()
profile=Unicode()
def _profile_default(self):
@@ -299,6 +302,7 @@ def __init__(self, url_or_file=None, profile=None, profile_dir=None, ipython_dir
if context is None:
context = zmq.Context.instance()
self._context = context
+ self._stop_spinning = Event()
self._setup_profile_dir(self.profile, profile_dir, ipython_dir)
if self._cd is not None:
@@ -785,12 +789,59 @@ def ids(self):
def close(self):
if self._closed:
return
+ self.stop_spin_thread()
snames = filter(lambda n: n.endswith('socket'), dir(self))
for socket in map(lambda name: getattr(self, name), snames):
if isinstance(socket, zmq.Socket) and not socket.closed:
socket.close()
self._closed = True
+ def _spin_every(self, interval=1):
+ """target func for use in spin_thread"""
+ while True:
+ if self._stop_spinning.is_set():
+ return
+ time.sleep(interval)
+ self.spin()
+
+ def spin_thread(self, interval=1):
+ """call Client.spin() in a background thread on some regular interval
+
+ This helps ensure that messages don't pile up too much in the zmq queue
+ while you are working on other things, or just leaving an idle terminal.
+
+ It also helps limit potential padding of the `received` timestamp
+ on AsyncResult objects, used for timings.
+
+ Parameters
+ ----------
+
+ interval : float, optional
+ The interval on which to spin the client in the background thread
+ (simply passed to time.sleep).
+
+ Notes
+ -----
+
+ For precision timing, you may want to use this method to put a bound
+ on the jitter (in seconds) in `received` timestamps used
+ in AsyncResult.wall_time.
+
+ """
+ if self._spin_thread is not None:
+ self.stop_spin_thread()
+ self._stop_spinning.clear()
+ self._spin_thread = Thread(target=self._spin_every, args=(interval,))
+ self._spin_thread.daemon = True
+ self._spin_thread.start()
+
+ def stop_spin_thread(self):
+ """stop background spin_thread, if any"""
+ if self._spin_thread is not None:
+ self._stop_spinning.set()
+ self._spin_thread.join()
+ self._spin_thread = None
+
def spin(self):
"""Flush any registration notifications and execution results
waiting in the ZMQ queue.
@@ -1277,6 +1328,8 @@ def result_status(self, msg_ids, status_only=True):
md = self.metadata[msg_id]
md.update(self._extract_metadata(header, parent, rcontent))
+ if rec.get('received'):
+ md['received'] = rec['received']
md.update(iodict)
if rcontent['status'] == 'ok':
View
9 IPython/parallel/controller/hub.py
@@ -63,6 +63,7 @@ def empty_record():
'started': None,
'completed': None,
'resubmitted': None,
+ 'received': None,
'result_header' : None,
'result_content' : None,
'result_buffers' : None,
@@ -88,6 +89,7 @@ def init_record(msg):
'started': None,
'completed': None,
'resubmitted': None,
+ 'received': None,
'result_header' : None,
'result_content' : None,
'result_buffers' : None,
@@ -630,6 +632,7 @@ def save_queue_result(self, idents, msg):
result = {
'result_header' : rheader,
'result_content': msg['content'],
+ 'received': datetime.now(),
'started' : started,
'completed' : completed
}
@@ -732,7 +735,8 @@ def save_task_result(self, idents, msg):
'result_content': msg['content'],
'started' : started,
'completed' : completed,
- 'engine_uuid': engine_uuid
+ 'received' : datetime.now(),
+ 'engine_uuid': engine_uuid,
}
result['result_buffers'] = msg['buffers']
@@ -1176,11 +1180,12 @@ def finish(reply):
def _extract_record(self, rec):
"""decompose a TaskRecord dict into subsection of reply for get_result"""
io_dict = {}
- for key in 'pyin pyout pyerr stdout stderr'.split():
+ for key in ('pyin', 'pyout', 'pyerr', 'stdout', 'stderr'):
io_dict[key] = rec[key]
content = { 'result_content': rec['result_content'],
'header': rec['header'],
'result_header' : rec['result_header'],
+ 'received' : rec['received'],
'io' : io_dict,
}
if rec['result_buffers']:
View
3  IPython/parallel/controller/sqlitedb.py
@@ -117,6 +117,7 @@ class SQLiteDB(BaseDB):
'started',
'completed',
'resubmitted',
+ 'received',
'result_header' ,
'result_content' ,
'result_buffers' ,
@@ -138,6 +139,7 @@ class SQLiteDB(BaseDB):
'started' : 'timestamp',
'completed' : 'timestamp',
'resubmitted' : 'timestamp',
+ 'received' : 'timestamp',
'result_header' : 'dict text',
'result_content' : 'dict text',
'result_buffers' : 'bufs blob',
@@ -245,6 +247,7 @@ def _init_db(self):
started timestamp,
completed timestamp,
resubmitted timestamp,
+ received timestamp,
result_header dict text,
result_content dict text,
result_buffers bufs blob,
View
82 IPython/parallel/tests/test_asyncresult.py
@@ -16,10 +16,11 @@
# Imports
#-------------------------------------------------------------------------------
+import time
from IPython.parallel.error import TimeoutError
-from IPython.parallel import error
+from IPython.parallel import error, Client
from IPython.parallel.tests import add_engines
from .clienttest import ClusterTestCase
@@ -121,5 +122,84 @@ def test_abort(self):
ar2.abort()
self.assertRaises(error.TaskAborted, ar2.get)
ar.get()
+
+ def test_len(self):
+ v = self.client.load_balanced_view()
+ ar = v.map_async(lambda x: x, range(10))
+ self.assertEquals(len(ar), 10)
+ ar = v.apply_async(lambda x: x, range(10))
+ self.assertEquals(len(ar), 1)
+ ar = self.client[:].apply_async(lambda x: x, range(10))
+ self.assertEquals(len(ar), len(self.client.ids))
+
+ def test_wall_time_single(self):
+ v = self.client.load_balanced_view()
+ ar = v.apply_async(time.sleep, 0.25)
+ self.assertRaises(TimeoutError, getattr, ar, 'wall_time')
+ ar.get(2)
+ self.assertTrue(ar.wall_time < 1.)
+ self.assertTrue(ar.wall_time > 0.2)
+
+ def test_wall_time_multi(self):
+ self.minimum_engines(4)
+ v = self.client[:]
+ ar = v.apply_async(time.sleep, 0.25)
+ self.assertRaises(TimeoutError, getattr, ar, 'wall_time')
+ ar.get(2)
+ self.assertTrue(ar.wall_time < 1.)
+ self.assertTrue(ar.wall_time > 0.2)
+
+ def test_serial_time_single(self):
+ v = self.client.load_balanced_view()
+ ar = v.apply_async(time.sleep, 0.25)
+ self.assertRaises(TimeoutError, getattr, ar, 'serial_time')
+ ar.get(2)
+ self.assertTrue(ar.serial_time < 0.5)
+ self.assertTrue(ar.serial_time > 0.2)
+
+ def test_serial_time_multi(self):
+ self.minimum_engines(4)
+ v = self.client[:]
+ ar = v.apply_async(time.sleep, 0.25)
+ self.assertRaises(TimeoutError, getattr, ar, 'serial_time')
+ ar.get(2)
+ self.assertTrue(ar.serial_time < 2.)
+ self.assertTrue(ar.serial_time > 0.8)
+
+ def test_elapsed_single(self):
+ v = self.client.load_balanced_view()
+ ar = v.apply_async(time.sleep, 0.25)
+ while not ar.ready():
+ time.sleep(0.01)
+ self.assertTrue(ar.elapsed < 0.3)
+ self.assertTrue(ar.elapsed < 0.3)
+ ar.get(2)
+
+ def test_elapsed_multi(self):
+ v = self.client[:]
+ ar = v.apply_async(time.sleep, 0.25)
+ while not ar.ready():
+ time.sleep(0.01)
+ self.assertTrue(ar.elapsed < 0.3)
+ self.assertTrue(ar.elapsed < 0.3)
+ ar.get(2)
+
+ def test_hubresult_timestamps(self):
+ self.minimum_engines(4)
+ v = self.client[:]
+ ar = v.apply_async(time.sleep, 0.25)
+ ar.get(2)
+ rc2 = Client(profile='iptest')
+ # must have try/finally to close second Client, otherwise
+ # will have dangling sockets causing problems
+ try:
+ time.sleep(0.25)
+ hr = rc2.get_result(ar.msg_ids)
+ self.assertTrue(hr.elapsed > 0., "got bad elapsed: %s" % hr.elapsed)
+ hr.get(1)
+ self.assertTrue(hr.wall_time < ar.wall_time + 0.2, "got bad wall_time: %s > %s" % (hr.wall_time, ar.wall_time))
+ self.assertEquals(hr.serial_time, ar.serial_time)
+ finally:
+ rc2.close()
View
18 IPython/parallel/tests/test_client.py
@@ -316,4 +316,22 @@ def test_purge_all_results(self):
self.client.purge_results('all')
hist = self.client.hub_history()
self.assertEquals(len(hist), 0)
+
+ def test_spin_thread(self):
+ self.client.spin_thread(0.01)
+ ar = self.client[-1].apply_async(lambda : 1)
+ time.sleep(0.1)
+ self.assertTrue(ar.wall_time < 0.1,
+ "spin should have kept wall_time < 0.1, but got %f" % ar.wall_time
+ )
+
+ def test_stop_spin_thread(self):
+ self.client.spin_thread(0.01)
+ self.client.stop_spin_thread()
+ ar = self.client[-1].apply_async(lambda : 1)
+ time.sleep(0.15)
+ self.assertTrue(ar.wall_time > 0.1,
+ "Shouldn't be spinning, but got wall_time=%f" % ar.wall_time
+ )
+
View
274 docs/examples/notebooks/Animations_and_Progress.ipynb
@@ -0,0 +1,274 @@
+{
+ "metadata": {
+ "name": "Animations_and_Progress"
+ },
+ "nbformat": 3,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "source": [
+ "Simple animations, progress bars, and clearing output"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Sometimes you want to print progress in-place, but don't want",
+ "to keep growing the output area. In terminals, there is the carriage-return",
+ "(`'\\r'`) for overwriting a single line, but the notebook frontend does not support this",
+ "behavior (yet).",
+ "",
+ "What the notebook *does* support is explicit `clear_output`, and you can use this to replace previous",
+ "output (specifying stdout/stderr or the special IPython display outputs)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "A simple example printing our progress iterating through a list:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "import sys",
+ "import time"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 16
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "from IPython.core.display import clear_output",
+ "for i in range(10):",
+ " time.sleep(0.25)",
+ " clear_output()",
+ " print i",
+ " sys.stdout.flush()"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 12
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "The AsyncResult object has a special `wait_interactive()` method, which prints its progress interactively,",
+ "so you can watch as your parallel computation completes.",
+ "",
+ "**This example assumes you have an IPython cluster running, which you can start from the [cluster panel](/#tab2)**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "from IPython import parallel",
+ "rc = parallel.Client()",
+ "view = rc.load_balanced_view()",
+ "",
+ "amr = view.map_async(time.sleep, [0.5]*100)",
+ "",
+ "amr.wait_interactive()"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 13
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "You can also use `clear_output()` to clear figures and plots.",
+ "",
+ "This time, we need to make sure we are using inline pylab (**requires matplotlib**)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "%pylab inline"
+ ],
+ "language": "python",
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "",
+ "Welcome to pylab, a matplotlib-based Python environment [backend: module://IPython.zmq.pylab.backend_inline].",
+ "For more information, type 'help(pylab)'."
+ ]
+ }
+ ],
+ "prompt_number": 17
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "from scipy.special import jn",
+ "x = linspace(0,5)",
+ "f, ax = plt.subplots()",
+ "ax.set_title(\"Bessel functions\")",
+ "",
+ "for n in range(1,10):",
+ " time.sleep(1)",
+ " ax.plot(x, jn(x,n))",
+ " clear_output()",
+ " display(f)",
+ "",
+ "# close the figure at the end, so we don't get a duplicate",
+ "# of the last plot",
+ "plt.close()"
+ ],
+ "language": "python",
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEICAYAAABRSj9aAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n",
+ "text": [
+ "<matplotlib.figure.Figure at 0x1083272d0>"
+ ]
+ }
+ ],
+ "prompt_number": 20
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "source": [
+ "A Javascript Progress Bar"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "`clear_output()` is still something of a hack, and if you want to do a progress bar in the notebook",
+ "it is better to just use Javascript/HTML if you can.",
+ "",
+ "Here is a simple progress bar using HTML/Javascript:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import uuid",
+ "from IPython.core.display import HTML, Javascript, display",
+ "",
+ "divid = str(uuid.uuid4())",
+ "",
+ "pb = HTML(",
+ "\"\"\"",
+ "<div style=\"border: 1px solid black; width:500px\">",
+ " <div id=\"%s\" style=\"background-color:blue; width:0%%\">&nbsp;</div>",
+ "</div> ",
+ "\"\"\" % divid)",
+ "display(pb)",
+ "for i in range(1,101):",
+ " time.sleep(0.1)",
+ " ",
+ " display(Javascript(\"$('div#%s').width('%i%%')\" % (divid, i)))"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 15
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "The above simply makes a div that is a box, and a blue div inside it with a unique ID ",
+ "(so that the javascript won't collide with other similar progress bars on the same page). ",
+ "",
+ "Then, at every progress point, we run a simple jQuery call to resize the blue box to",
+ "the appropriate fraction of the width of its containing box, and voil\u00e0 a nice",
+ "HTML/Javascript progress bar!"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "source": [
+ "ProgressBar class"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "And finally, here is a progress bar *class* extracted from [PyMC](http://code.google.com/p/pymc/), which will work in regular Python as well as in the IPython Notebook"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "import sys, time",
+ "try:",
+ " from IPython.core.display import clear_output",
+ " have_ipython = True",
+ "except ImportError:",
+ " have_ipython = False",
+ "",
+ "class ProgressBar:",
+ " def __init__(self, iterations):",
+ " self.iterations = iterations",
+ " self.prog_bar = '[]'",
+ " self.fill_char = '*'",
+ " self.width = 40",
+ " self.__update_amount(0)",
+ " if have_ipython:",
+ " self.animate = self.animate_ipython",
+ " else:",
+ " self.animate = self.animate_noipython",
+ "",
+ " def animate_ipython(self, iter):",
+ " clear_output()",
+ " print '\\r', self,",
+ " sys.stdout.flush()",
+ " self.update_iteration(iter + 1)",
+ "",
+ " def update_iteration(self, elapsed_iter):",
+ " self.__update_amount((elapsed_iter / float(self.iterations)) * 100.0)",
+ " self.prog_bar += ' %d of %s complete' % (elapsed_iter, self.iterations)",
+ "",
+ " def __update_amount(self, new_amount):",
+ " percent_done = int(round((new_amount / 100.0) * 100.0))",
+ " all_full = self.width - 2",
+ " num_hashes = int(round((percent_done / 100.0) * all_full))",
+ " self.prog_bar = '[' + self.fill_char * num_hashes + ' ' * (all_full - num_hashes) + ']'",
+ " pct_place = (len(self.prog_bar) / 2) - len(str(percent_done))",
+ " pct_string = '%d%%' % percent_done",
+ " self.prog_bar = self.prog_bar[0:pct_place] + \\",
+ " (pct_string + self.prog_bar[pct_place + len(pct_string):])",
+ "",
+ " def __str__(self):",
+ " return str(self.prog_bar)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 10
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "p = ProgressBar(1000)",
+ "for i in range(1001):",
+ " p.animate(i)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 11
+ }
+ ]
+ }
+ ]
+}
View
116 docs/source/parallel/asyncresult.txt
@@ -0,0 +1,116 @@
+.. _parallel_asyncresult:
+
+======================
+The AsyncResult object
+======================
+
+In non-blocking mode, :meth:`apply` submits the command to be executed and
+then returns a :class:`~.AsyncResult` object immediately. The
+AsyncResult object gives you a way of getting a result at a later
+time through its :meth:`get` method, but it also collects metadata
+on execution.
+
+
+Beyond multiprocessing's AsyncResult
+====================================
+
+.. Note::
+
+ The :class:`~.AsyncResult` object provides a superset of the interface in
+ :py:class:`multiprocessing.pool.AsyncResult`. See the
+ `official Python documentation <http://docs.python.org/library/multiprocessing#multiprocessing.pool.AsyncResult>`_
+ for more on the basics of this interface.
+
+Our AsyncResult objects add a number of convenient features for working with
+parallel results, beyond what is provided by the original AsyncResult.
+
+
+get_dict
+--------
+
+First, is :meth:`.AsyncResult.get_dict`, which pulls results as a dictionary
+keyed by engine_id, rather than a flat list. This is useful for quickly
+coordinating or distributing information about all of the engines.
+
+As an example, here is a quick call that gives every engine a dict showing
+the PID of every other engine:
+
+.. sourcecode:: ipython
+
+ In [10]: ar = rc[:].apply_async(os.getpid)
+ In [11]: pids = ar.get_dict()
+ In [12]: rc[:]['pid_map'] = pids
+
+This trick is particularly useful when setting up inter-engine communication,
+as in IPython's :file:`examples/parallel/interengine` examples.
+
+
+Metadata
+========
+
+IPython.parallel tracks some metadata about the tasks, which is stored
+in the :attr:`.Client.metadata` dict. The AsyncResult object gives you an
+interface for this information as well, including timestamps stdout/err,
+and engine IDs.
+
+
+Timing
+------
+
+IPython tracks various timestamps as :py:class:`.datetime` objects,
+and the AsyncResult object has a few properties that turn these into useful
+times (in seconds as floats).
+
+For use while the tasks are still pending:
+
+* :attr:`ar.elapsed` is just the elapsed seconds since submission, for use
+ before the AsyncResult is complete.
+* :attr:`ar.progress` is the number of tasks that have completed. Fractional progress
+ would be::
+
+ 1.0 * ar.progress / len(ar)
+
+* :meth:`AsyncResult.wait_interactive` will wait for the result to finish, but
+ print out status updates on progress and elapsed time while it waits.
+
+For use after the tasks are done:
+
+* :attr:`ar.serial_time` is the sum of the computation time of all of the tasks
+ done in parallel.
+* :attr:`ar.wall_time` is the time between the first task submitted and last result
+ received. This is the actual cost of computation, including IPython overhead.
+
+
+.. note::
+
+ wall_time is only precise if the Client is waiting for results when
+ the task finished, because the `received` timestamp is made when the result is
+ unpacked by the Client, triggered by the :meth:`~Client.spin` call. If you
+ are doing work in the Client, and not waiting/spinning, then `received` might
+ be artificially high.
+
+An often interesting metric is the time it actually cost to do the work in parallel
+relative to the serial computation, and this can be given simply with
+
+.. sourcecode:: python
+
+ speedup = ar.serial_time / ar.wall_time
+
+
+Map results are iterable!
+=========================
+
+When an AsyncResult object has multiple results (e.g. the :class:`~AsyncMapResult`
+object), you can actually iterate through them, and act on the results as they arrive:
+
+.. literalinclude:: ../../examples/parallel/itermapresult.py
+ :language: python
+ :lines: 20-66
+
+.. seealso::
+
+ When AsyncResult or the AsyncMapResult don't provide what you need (for instance,
+ handling individual results as they arrive, but with metadata), you can always
+ just split the original result's ``msg_ids`` attribute, and handle them as you like.
+
+ For an example of this, see :file:`docs/examples/parallel/customresult.py`
View
1  docs/source/parallel/index.txt
@@ -11,6 +11,7 @@ Using IPython for parallel computing
parallel_process.txt
parallel_multiengine.txt
parallel_task.txt
+ asyncresult.txt
parallel_mpi.txt
parallel_db.txt
parallel_security.txt
View
8 docs/source/parallel/parallel_multiengine.txt
@@ -275,13 +275,9 @@ then returns a :class:`AsyncResult` object immediately. The
:class:`AsyncResult` object gives you a way of getting a result at a later
time through its :meth:`get` method.
-.. Note::
-
- The :class:`AsyncResult` object provides a superset of the interface in
- :py:class:`multiprocessing.pool.AsyncResult`. See the
- `official Python documentation <http://docs.python.org/library/multiprocessing#multiprocessing.pool.AsyncResult>`_
- for more.
+.. seealso::
+ Docs on the :ref:`AsyncResult <parallel_asyncresult>` object.
This allows you to quickly submit long running commands without blocking your
local Python/IPython session:
View
21 docs/source/parallel/parallel_task.txt
@@ -111,27 +111,6 @@ that turns any Python function into a parallel function:
In [11]: f.map(range(32)) # this is done in parallel
Out[11]: [0.0,10.0,160.0,...]
-.. _parallel_taskmap:
-
-Map results are iterable!
--------------------------
-
-When an AsyncResult object actually maps multiple results (e.g. the :class:`~AsyncMapResult`
-object), you can actually iterate through them, and act on the results as they arrive:
-
-.. literalinclude:: ../../examples/parallel/itermapresult.py
- :language: python
- :lines: 9-34
-
-.. seealso::
-
- When AsyncResult or the AsyncMapResult don't provide what you need (for instance,
- handling individual results as they arrive, but with metadata), you can always
- just split the original result's ``msg_ids`` attribute, and handle them as you like.
-
- For an example of this, see :file:`docs/examples/parallel/customresult.py`
-
-
.. _parallel_dependencies:
Dependencies
Something went wrong with that request. Please try again.