move parallel doc figures into 'figs' subdir

also fix a few broken links after some renames in the examples dir.

docs/source/parallel/dag_dependencies.txt

@@ -10,7 +10,7 b' for working with Graphs is NetworkX_. Here, we will walk through a demo mapping'
 a nx DAG to task dependencies.
 
 The full script that runs this demo can be found in
-:file:`docs/examples/newparallel/dagdeps.py`.
+:file:`docs/examples/parallel/dagdeps.py`.
 
 Why are DAGs good for task dependencies?
 ----------------------------------------
@@ -30,7 +30,7 b' A Sample DAG'
 
 Here, we have a very simple 5-node DAG:
 
-.. figure:: simpledag.*
+.. figure:: figs/ simpledag.*
 
 With NetworkX, an arrow is just a fattened bit on the edge. Here, we can see that task 0
 depends on nothing, and can run immediately. 1 and 2 depend on 0; 3 depends on
@@ -80,7 +80,7 b' The code to generate the simple DAG:'
 For demonstration purposes, we have a function that generates a random DAG with a given
 number of nodes and edges.
 
-.. literalinclude:: ../../examples/newparallel/dagdeps.py
+.. literalinclude:: ../../examples/parallel/dagdeps.py
     :language: python
     :lines: 20-36
 
@@ -137,7 +137,7 b' These objects store a variety of metadata about each task, including various tim'
 We can validate that the dependencies were respected by checking that each task was
 started after all of its predecessors were completed:
 
-.. literalinclude:: ../../examples/newparallel/dagdeps.py
+.. literalinclude:: ../../examples/parallel/dagdeps.py
     :language: python
     :lines: 64-70
 
@@ -164,7 +164,7 b' will be at the top, and quick, small tasks will be at the bottom.'
     In [13]: nx.draw(G, pos, node_list=colors.keys(), node_color=colors.values(),
         ...:    cmap=gist_rainbow)
 
-.. figure:: dagdeps.*
+.. figure:: figs/ dagdeps.*
 
     Time started on x, runtime on y, and color-coded by engine-id (in this case there
     were four engines). Edges denote dependencies.

docs/source/parallel/parallel_demos.txt

@@ -4,7 +4,7 b' Parallel examples'
 
 .. note::
 
-    Performance numbers from ``IPython.kernel``, not newparallel.
+    Performance numbers from ``IPython.kernel``, not new ``IPython.parallel``.
 
 In this section we describe two more involved examples of using an IPython
 cluster to perform a parallel computation. In these examples, we will be using
@@ -27,7 +27,7 b' million digits.'
 
 In both the serial and parallel calculation we will be using functions defined
 in the :file:`pidigits.py` file, which is available in the
-:file:`docs/examples/newparallel` directory of the IPython source distribution.
+:file:`docs/examples/parallel` directory of the IPython source distribution.
 These functions provide basic facilities for working with the digits of pi and
 can be loaded into IPython by putting :file:`pidigits.py` in your current
 working directory and then doing:
@@ -75,7 +75,7 b' The resulting plot of the single digit counts shows that each digit occurs'
 approximately 1,000 times, but that with only 10,000 digits the
 statistical fluctuations are still rather large:
 
-.. image:: single_digits.*
+.. image:: figs/single_digits.*
 
 It is clear that to reduce the relative fluctuations in the counts, we need
 to look at many more digits of pi. That brings us to the parallel calculation.
@@ -101,13 +101,13 b' compute the two digit counts for the digits in a single file. Then in a final'
 step the counts from each engine will be added up. To perform this
 calculation, we will need two top-level functions from :file:`pidigits.py`:
 
-.. literalinclude:: ../../examples/newparallel/pidigits.py
+.. literalinclude:: ../../examples/parallel/pi/pidigits.py
    :language: python
    :lines: 47-62
 
 We will also use the :func:`plot_two_digit_freqs` function to plot the
 results. The code to run this calculation in parallel is contained in
-:file:`docs/examples/newparallel/parallelpi.py`. This code can be run in parallel
+:file:`docs/examples/parallel/parallelpi.py`. This code can be run in parallel
 using IPython by following these steps:
 
 1. Use :command:`ipcluster` to start 15 engines. We used an 8 core (2 quad 
@@ -188,7 +188,7 b' most likely and that "06" and "07" are least likely. Further analysis would'
 show that the relative size of the statistical fluctuations have decreased
 compared to the 10,000 digit calculation.
 
-.. image:: two_digit_counts.*
+.. image:: figs/two_digit_counts.*
 
 
 Parallel options pricing
@@ -209,12 +209,12 b' simulation of the underlying asset price. In this example we use this approach'
 to price both European and Asian (path dependent) options for various strike
 prices and volatilities.
 
-The code for this example can be found in the :file:`docs/examples/newparallel`
+The code for this example can be found in the :file:`docs/examples/parallel`
 directory of the IPython source. The function :func:`price_options` in
 :file:`mcpricer.py` implements the basic Monte Carlo pricing algorithm using
 the NumPy package and is shown here:
 
-.. literalinclude:: ../../examples/newparallel/mcpricer.py
+.. literalinclude:: ../../examples/parallel/options/mcpricer.py
    :language: python
 
 To run this code in parallel, we will use IPython's :class:`LoadBalancedView` class,
@@ -222,21 +222,21 b' which distributes work to the engines using dynamic load balancing. This'
 view is a wrapper of the :class:`Client` class shown in
 the previous example. The parallel calculation using :class:`LoadBalancedView` can
 be found in the file :file:`mcpricer.py`. The code in this file creates a
-:class:`TaskClient` instance and then submits a set of tasks using
-:meth:`TaskClient.run` that calculate the option prices for different
+:class:`LoadBalancedView` instance and then submits a set of tasks using
+:meth:`LoadBalancedView.apply` that calculate the option prices for different
 volatilities and strike prices. The results are then plotted as a 2D contour
 plot using Matplotlib.
 
-.. literalinclude:: ../../examples/newparallel/mcdriver.py
+.. literalinclude:: ../../examples/parallel/options/mckernel.py
    :language: python
 
 To use this code, start an IPython cluster using :command:`ipcluster`, open
-IPython in the pylab mode with the file :file:`mcdriver.py` in your current
+IPython in the pylab mode with the file :file:`mckernel.py` in your current
 working directory and then type:
 
 .. sourcecode:: ipython
 
-    In [7]: run mcdriver.py
+    In [7]: run mckernel.py
     Submitted tasks:  [0, 1, 2, ...]
 
 Once all the tasks have finished, the results can be plotted using the
@@ -257,9 +257,9 b' entire calculation (10 strike prices, 10 volatilities, 100,000 paths for each)'
 took 30 seconds in parallel, giving a speedup of 7.7x, which is comparable
 to the speedup observed in our previous example.
 
-.. image:: asian_call.*
+.. image:: figs/asian_call.*
 
-.. image:: asian_put.*
+.. image:: figs/asian_put.*
 
 Conclusion
 ==========

docs/source/parallel/parallel_task.txt

@@ -111,6 +111,15 b' 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:
+
+The AsyncMapResult
+==================
+
+When you call ``lview.map_async(f, sequence)``, or just :meth:`map` with `block=True`, then
+what you get in return will be an :class:`~AsyncMapResult` object. These are similar to 
+AsyncResult objects, but with one key difference
+
 .. _parallel_dependencies:
 
 Dependencies
@@ -291,8 +300,6 b' you can skip using Dependency objects, and just pass msg_ids or AsyncResult obje'
     onto task dependencies.
 
 
-
-
 Impossible Dependencies
 ***********************
 

docs/source/parallel/parallel_winhpc.txt

@@ -120,7 +120,7 b' opening a Windows Command Prompt and typing ``ipython``. This will'
 start IPython's interactive shell and you should see something like the
 following screenshot:
 
-.. image:: ipython_shell.*
+.. image:: figs/ipython_shell.*
 
 Starting an IPython cluster
 ===========================
@@ -168,7 +168,7 b' You should see a number of messages printed to the screen, ending with'
 "IPython cluster: started". The result should look something like the following
 screenshot:
 
-.. image:: ipcluster_start.*
+.. image:: figs/ipcluster_start.*
 
 At this point, the controller and two engines are running on your local host.
 This configuration is useful for testing and for situations where you want to
@@ -210,7 +210,7 b' The output of this command is shown in the screenshot below. Notice how'
 :command:`ipcluster` prints out the location of the newly created cluster
 directory.
 
-.. image:: ipcluster_create.*
+.. image:: figs/ipcluster_create.*
 
 Configuring a cluster profile
 -----------------------------
@@ -279,7 +279,7 b' must be run again to regenerate the XML job description files. The'
 following screenshot shows what the HPC Job Manager interface looks like
 with a running IPython cluster.
 
-.. image:: hpc_job_manager.*
+.. image:: figs/hpc_job_manager.*
 
 Performing a simple interactive parallel computation
 ====================================================
@@ -330,5 +330,5 b" The :meth:`map` method has the same signature as Python's builtin :func:`map`"
 function, but runs the calculation in parallel. More involved examples of using
 :class:`MultiEngineClient` are provided in the examples that follow.
 
-.. image:: mec_simple.*
+.. image:: figs/mec_simple.*