parallelz updates

docs/source/parallelz/parallel_demos.txt

@@ -116,7 +116,7 b' using IPython by following these steps:'
 1. Copy the text files with the digits of pi 
    (ftp://pi.super-computing.org/.2/pi200m/) to the working directory of the
    engines on the compute nodes.
-2. Use :command:`ipcluster` to start 15 engines. We used an 8 core (2 quad 
+2. Use :command:`ipclusterz` to start 15 engines. We used an 8 core (2 quad 
    core CPUs) cluster with hyperthreading enabled which makes the 8 cores 
    looks like 16 (1 controller + 15 engines) in the OS. However, the maximum
    speedup we can observe is still only 8x.
@@ -133,13 +133,13 b' calculation can also be run by simply typing the commands from'
 
 .. sourcecode:: ipython
 
-    In [1]: from IPython.kernel import client
+    In [1]: from IPython.zmq.parallel import client
     2009-11-19 11:32:38-0800 [-] Log opened.
 
     # The MultiEngineClient allows us to use the engines interactively.
     # We simply pass MultiEngineClient the name of the cluster profile we
     # are using.
-    In [2]: mec = client.MultiEngineClient(profile='mycluster')
+    In [2]: c = client.Client(profile='mycluster')
     2009-11-19 11:32:44-0800 [-] Connecting [0]
     2009-11-19 11:32:44-0800 [Negotiation,client] Connected: ./ipcontroller-mec.furl
 
@@ -233,7 +233,7 b' plot using Matplotlib.'
 .. literalinclude:: ../../examples/kernel/mcdriver.py
    :language: python
 
-To use this code, start an IPython cluster using :command:`ipcluster`, open
+To use this code, start an IPython cluster using :command:`ipclusterz`, open
 IPython in the pylab mode with the file :file:`mcdriver.py` in your current
 working directory and then type:
 

docs/source/parallelz/parallel_mpi.txt

@@ -4,6 +4,10 b''
 Using MPI with IPython
 =======================
 
+.. note::
+
+    Not adapted to zmq yet
+
 Often, a parallel algorithm will require moving data between the engines. One
 way of accomplishing this is by doing a pull and then a push using the
 multiengine client. However, this will be slow as all the data has to go
@@ -45,16 +49,16 b' To use code that calls MPI, there are typically two things that MPI requires.'
 There are a couple of ways that you can start the IPython engines and get
 these things to happen.
 
-Automatic starting using :command:`mpiexec` and :command:`ipcluster`
+Automatic starting using :command:`mpiexec` and :command:`ipclusterz`
 --------------------------------------------------------------------
 
-The easiest approach is to use the `mpiexec` mode of :command:`ipcluster`,
+The easiest approach is to use the `mpiexec` mode of :command:`ipclusterz`,
 which will first start a controller and then a set of engines using
 :command:`mpiexec`::
 
-    $ ipcluster mpiexec -n 4
+    $ ipclusterz mpiexec -n 4
 
-This approach is best as interrupting :command:`ipcluster` will automatically
+This approach is best as interrupting :command:`ipclusterz` will automatically
 stop and clean up the controller and engines.
 
 Manual starting using :command:`mpiexec`
@@ -72,11 +76,11 b' starting the engines with::'
 
     	mpiexec -n 4 ipengine --mpi=pytrilinos
 
-Automatic starting using PBS and :command:`ipcluster`
+Automatic starting using PBS and :command:`ipclusterz`
 -----------------------------------------------------
 
-The :command:`ipcluster` command also has built-in integration with PBS. For
-more information on this approach, see our documentation on :ref:`ipcluster
+The :command:`ipclusterz` command also has built-in integration with PBS. For
+more information on this approach, see our documentation on :ref:`ipclusterz
 <parallel_process>`.
 
 Actually using MPI
@@ -105,7 +109,7 b' distributed array. Save the following text in a file called :file:`psum.py`:'
 
 Now, start an IPython cluster in the same directory as :file:`psum.py`::
 
-    $ ipcluster mpiexec -n 4
+    $ ipclusterz mpiexec -n 4
 
 Finally, connect to the cluster and use this function interactively. In this
 case, we create a random array on each engine and sum up all the random arrays
@@ -113,9 +117,9 b' using our :func:`psum` function:'
 
 .. sourcecode:: ipython
 
-    In [1]: from IPython.kernel import client
+    In [1]: from IPython.zmq.parallel import client
     
-    In [2]: mec = client.MultiEngineClient()
+    In [2]: c = client.Client()
     
     In [3]: mec.activate()
     

docs/source/parallelz/parallel_multiengine.txt

@@ -110,8 +110,7 b' some decorators:'
        ....: 
 
     In [11]: map(f, range(32))    # this is done in parallel
-    Out[11]: 
-    [0.0,10.0,160.0,...]
+    Out[11]: [0.0,10.0,160.0,...]
 
 See the docstring for the :func:`parallel` and :func:`remote` decorators for
 options.
@@ -185,7 +184,7 b' blocks until the engines are done executing the command:'
     In [5]: dview['b'] = 10
 
     In [6]: dview.apply_bound(lambda x: a+b+x, 27)
-    Out[6]: {0: 42, 1: 42, 2: 42, 3: 42}
+    Out[6]: [42,42,42,42]
 
 Python commands can be executed on specific engines by calling execute using
 the ``targets`` keyword argument, or creating a :class:`DirectView` instance
@@ -198,7 +197,7 b' by index-access to the client:'
     In [7]: rc.execute('c=a-b',targets=[1,3])
 
     In [8]: rc[:]['c'] # shorthand for rc.pull('c',targets='all')
-    Out[8]: {0: 15, 1: -5, 2: 15, 3: -5}
+    Out[8]: [15,-5,15,-5]
 
 .. note::
 
@@ -425,7 +424,7 b' engines specified by the :attr:`targets` attribute of the'
 
     In [26]: %px import numpy
     Parallel execution on engines: [0, 1, 2, 3]
-    Out[26]:{0: None, 1: None, 2: None, 3: None}
+    Out[26]:[None,None,None,None]
 
     In [27]: %px a = numpy.random.rand(2,2)
     Parallel execution on engines: [0, 1, 2, 3]
@@ -434,10 +433,11 b' engines specified by the :attr:`targets` attribute of the'
     Parallel execution on engines: [0, 1, 2, 3]
 
     In [28]: dv['ev']
-    Out[44]: {0: array([ 1.09522024, -0.09645227]), 
-            1: array([ 1.21435496, -0.35546712]), 
-            2: array([ 0.72180653,  0.07133042]), 
-            3: array([  1.46384341e+00,   1.04353244e-04])}
+    Out[44]: [ array([ 1.09522024, -0.09645227]), 
+               array([ 1.21435496, -0.35546712]), 
+               array([ 0.72180653,  0.07133042]), 
+               array([  1.46384341e+00,   1.04353244e-04])
+             ]
 
 .. Note::
 
@@ -496,10 +496,10 b' on the engines given by the :attr:`targets` attribute:'
     Parallel execution on engines: [0, 1, 2, 3]
     
     In [37]: dv['ans']
-    Out[37]: {0 : 'Average max eigenvalue is:  10.1387247332',
-              1 : 'Average max eigenvalue is:  10.2076902286',
-              2 : 'Average max eigenvalue is:  10.1891484655',
-              3 : 'Average max eigenvalue is:  10.1158837784',}
+    Out[37]: [ 'Average max eigenvalue is:  10.1387247332',
+               'Average max eigenvalue is:  10.2076902286',
+               'Average max eigenvalue is:  10.1891484655',
+               'Average max eigenvalue is:  10.1158837784',]
 
 
 .. Note::
@@ -524,23 +524,23 b' Here are some examples of how you use :meth:`push` and :meth:`pull`:'
 .. sourcecode:: ipython
 
     In [38]: rc.push(dict(a=1.03234,b=3453))
-    Out[38]: {0: None, 1: None, 2: None, 3: None}
+    Out[38]: [None,None,None,None]
 
     In [39]: rc.pull('a')
-    Out[39]: {0: 1.03234, 1: 1.03234, 2: 1.03234, 3: 1.03234}
+    Out[39]: [ 1.03234, 1.03234, 1.03234, 1.03234]
 
     In [40]: rc.pull('b',targets=0)
     Out[40]: 3453
 
     In [41]: rc.pull(('a','b'))
-    Out[41]: {0: [1.03234, 3453], 1: [1.03234, 3453], 2: [1.03234, 3453], 3:[1.03234, 3453]}
+    Out[41]: [ [1.03234, 3453], [1.03234, 3453], [1.03234, 3453], [1.03234, 3453] ]
     
     # zmq client does not have zip_pull
     In [42]: rc.zip_pull(('a','b'))
     Out[42]: [(1.03234, 1.03234, 1.03234, 1.03234), (3453, 3453, 3453, 3453)]
 
     In [43]: rc.push(dict(c='speed'))
-    Out[43]: {0: None, 1: None, 2: None, 3: None}
+    Out[43]: [None,None,None,None]
 
 In non-blocking mode :meth:`push` and :meth:`pull` also return
 :class:`AsyncResult` objects:
@@ -573,7 +573,7 b' appear as a local dictionary. Underneath, this uses :meth:`push` and'
     In [51]: rc[:]['a']=['foo','bar']
 
     In [52]: rc[:]['a']
-    Out[52]: {0: ['foo', 'bar'], 1: ['foo', 'bar'], 2: ['foo', 'bar'], 3: ['foo', 'bar']}
+    Out[52]: [ ['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar'] ]
 
 Scatter and gather
 ------------------
@@ -589,13 +589,10 b' between engines, MPI should be used:'
 .. sourcecode:: ipython
 
     In [58]: rc.scatter('a',range(16))
-    Out[58]: {0: None, 1: None, 2: None, 3: None}
+    Out[58]: [None,None,None,None]
 
     In [59]: rc[:]['a']
-    Out[59]: {0: [0, 1, 2, 3], 
-              1: [4, 5, 6, 7], 
-              2: [8, 9, 10, 11], 
-              3: [12, 13, 14, 15]}
+    Out[59]: [ [0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15] ]
 
     In [60]: rc.gather('a')
     Out[60]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
@@ -613,7 +610,7 b' basic effect using :meth:`scatter` and :meth:`gather`:'
 .. sourcecode:: ipython
 
     In [66]: rc.scatter('x',range(64))
-    Out[66]: {0: None, 1: None, 2: None, 3: None}
+    Out[66]: [None,None,None,None]
 
     In [67]: px y = [i**10 for i in x]
     Executing command on Controller
@@ -772,10 +769,6 b' instance:'
 
     ZeroDivisionError: integer division or modulo by zero
 
-.. note::
-
-    The above example appears to be broken right now because of a change in 
-    how we are using Twisted.
 
 All of this same error handling magic even works in non-blocking mode:
 

docs/source/parallelz/parallel_process.txt

@@ -4,6 +4,10 b''
 Starting the IPython controller and engines
 ===========================================
 
+.. note::
+
+    Not adapted to zmq yet
+
 To use IPython for parallel computing, you need to start one instance of
 the controller and one or more instances of the engine. The controller
 and each engine can run on different machines or on the same machine.
@@ -11,12 +15,12 b' Because of this, there are many different possibilities.'
 
 Broadly speaking, there are two ways of going about starting a controller and engines:
 
-* In an automated manner using the :command:`ipcluster` command.
+* In an automated manner using the :command:`ipclusterz` command.
 * In a more manual way using the :command:`ipcontroller` and 
   :command:`ipengine` commands.
 
 This document describes both of these methods. We recommend that new users
-start with the :command:`ipcluster` command as it simplifies many common usage
+start with the :command:`ipclusterz` command as it simplifies many common usage
 cases.
 
 General considerations
@@ -51,10 +55,10 b' be run. If these file are put into the :file:`~/.ipython/security` directory'
 of the client's host, they will be found automatically. Otherwise, the full
 path to them has to be passed to the client's constructor.
 
-Using :command:`ipcluster`
+Using :command:`ipclusterz`
 ==========================
 
-The :command:`ipcluster` command provides a simple way of starting a
+The :command:`ipclusterz` command provides a simple way of starting a
 controller and engines in the following situations:
 
 1. When the controller and engines are all run on localhost. This is useful
@@ -68,33 +72,33 b' controller and engines in the following situations:'
 .. note::
 
     It is also possible for advanced users to add support to
-    :command:`ipcluster` for starting controllers and engines using other
+    :command:`ipclusterz` for starting controllers and engines using other
     methods (like Sun's Grid Engine for example).
 
 .. note::
 
-    Currently :command:`ipcluster` requires that the
+    Currently :command:`ipclusterz` requires that the
     :file:`~/.ipython/security` directory live on a shared filesystem that is
     seen by both the controller and engines. If you don't have a shared file
     system you will need to use :command:`ipcontroller` and
     :command:`ipengine` directly.  This constraint can be relaxed if you are 
     using the :command:`ssh` method to start the cluster.
 
-Underneath the hood, :command:`ipcluster` just uses :command:`ipcontroller`
+Underneath the hood, :command:`ipclusterz` just uses :command:`ipcontroller`
 and :command:`ipengine` to perform the steps described above.
 
-Using :command:`ipcluster` in local mode
+Using :command:`ipclusterz` in local mode
 ----------------------------------------
 
 To start one controller and 4 engines on localhost, just do::
 
-    $ ipcluster local -n 4
+    $ ipclusterz -n 4
 
 To see other command line options for the local mode, do::
 
-    $ ipcluster local -h
+    $ ipclusterz -h
 
-Using :command:`ipcluster` in mpiexec/mpirun mode
+Using :command:`ipclusterz` in mpiexec/mpirun mode
 -------------------------------------------------
 
 The mpiexec/mpirun mode is useful if you:
@@ -112,7 +116,7 b' The mpiexec/mpirun mode is useful if you:'
 
 If these are satisfied, you can start an IPython cluster using::
 
-    $ ipcluster mpiexec -n 4
+    $ ipclusterz mpiexec -n 4
 
 This does the following:
 
@@ -123,25 +127,25 b' On newer MPI implementations (such as OpenMPI), this will work even if you'
 don't make any calls to MPI or call :func:`MPI_Init`. However, older MPI
 implementations actually require each process to call :func:`MPI_Init` upon
 starting. The easiest way of having this done is to install the mpi4py
-[mpi4py]_ package and then call ipcluster with the ``--mpi`` option::
+[mpi4py]_ package and then call ipclusterz with the ``--mpi`` option::
 
-    $ ipcluster mpiexec -n 4 --mpi=mpi4py
+    $ ipclusterz mpiexec -n 4 --mpi=mpi4py
 
 Unfortunately, even this won't work for some MPI implementations. If you are
 having problems with this, you will likely have to use a custom Python
 executable that itself calls :func:`MPI_Init` at the appropriate time.
 Fortunately, mpi4py comes with such a custom Python executable that is easy to
 install and use. However, this custom Python executable approach will not work
-with :command:`ipcluster` currently.
+with :command:`ipclusterz` currently.
 
 Additional command line options for this mode can be found by doing::
 
-    $ ipcluster mpiexec -h
+    $ ipclusterz mpiexec -h
 
 More details on using MPI with IPython can be found :ref:`here <parallelmpi>`.
 
 
-Using :command:`ipcluster` in PBS mode
+Using :command:`ipclusterz` in PBS mode
 --------------------------------------
 
 The PBS mode uses the Portable Batch System [PBS]_ to start the engines. To
@@ -184,13 +188,13 b' There are a few important points about this template:'
 Once you have created such a script, save it with a name like
 :file:`pbs.template`. Now you are ready to start your job::
 
-    $ ipcluster pbs -n 128 --pbs-script=pbs.template
+    $ ipclusterz pbs -n 128 --pbs-script=pbs.template
 
 Additional command line options for this mode can be found by doing::
 
-    $ ipcluster pbs -h
+    $ ipclusterz pbs -h
 
-Using :command:`ipcluster` in SSH mode
+Using :command:`ipclusterz` in SSH mode
 --------------------------------------
 
 The SSH mode uses :command:`ssh` to execute :command:`ipengine` on remote
@@ -225,7 +229,7 b' start your cluster like so:'
 
 .. sourcecode:: bash 
 
-   $ ipcluster ssh --clusterfile /path/to/my/clusterfile.py
+   $ ipclusterz ssh --clusterfile /path/to/my/clusterfile.py
 
 
 Two helper shell scripts are used to start and stop :command:`ipengine` on
@@ -235,7 +239,7 b' remote hosts:'
 * engine_killer.sh
 
 Defaults for both of these are contained in the source code for
-:command:`ipcluster`. The default scripts are written to a local file in a
+:command:`ipclusterz`. The default scripts are written to a local file in a
 tmep directory and then copied to a temp directory on the remote host and
 executed from there. On most Unix, Linux and OS X systems this is /tmp.
 
@@ -256,9 +260,9 b' For a detailed options list:'
 
 .. sourcecode:: bash
 
-   $ ipcluster ssh -h
+   $ ipclusterz ssh -h
 
-Current limitations of the SSH mode of :command:`ipcluster` are:
+Current limitations of the SSH mode of :command:`ipclusterz` are:
 
 * Untested on Windows. Would require a working :command:`ssh` on Windows.
   Also, we are using shell scripts to setup and execute commands on remote
@@ -358,9 +362,9 b' listen on for the engines and clients. This is done as follows::'
     $ ipcontroller -r --client-port=10101 --engine-port=10102
 
 These options also work with all of the various modes of
-:command:`ipcluster`::
+:command:`ipclusterz`::
 
-    $ ipcluster local -n 2 -r --client-port=10101 --engine-port=10102
+    $ ipclusterz -n 2 -r --client-port=10101 --engine-port=10102
 
 Then, just copy the furl files over the first time and you are set. You can
 start and stop the controller and engines any many times as you want in the

docs/source/parallelz/parallel_security.txt

@@ -4,11 +4,15 b''
 Security details of IPython
 ===========================
 
-IPython's :mod:`IPython.kernel` package exposes the full power of the Python
-interpreter over a TCP/IP network for the purposes of parallel computing. This
-feature brings up the important question of IPython's security model. This
-document gives details about this model and how it is implemented in IPython's
-architecture.
+.. note::
+
+    Not adapted to zmq yet
+
+IPython's :mod:`IPython.zmq.parallel` package exposes the full power of the
+Python interpreter over a TCP/IP network for the purposes of parallel
+computing. This feature brings up the important question of IPython's security
+model. This document gives details about this model and how it is implemented
+in IPython's architecture.
 
 Processs and network topology
 =============================

docs/source/parallelz/parallel_winhpc.txt

@@ -2,6 +2,10 b''
 Getting started with Windows HPC Server 2008
 ============================================
 
+.. note::
+
+    Not adapted to zmq yet
+
 Introduction
 ============
 
@@ -143,42 +147,42 b' in parallel on the engines from within the IPython shell using an appropriate'
 client. This includes the ability to interact with, plot and visualize data
 from the engines.
 
-IPython has a command line program called :command:`ipcluster` that automates
+IPython has a command line program called :command:`ipclusterz` that automates
 all aspects of starting the controller and engines on the compute nodes.
-:command:`ipcluster` has full support for the Windows HPC job scheduler,
-meaning that :command:`ipcluster` can use this job scheduler to start the
+:command:`ipclusterz` has full support for the Windows HPC job scheduler,
+meaning that :command:`ipclusterz` can use this job scheduler to start the
 controller and engines. In our experience, the Windows HPC job scheduler is
 particularly well suited for interactive applications, such as IPython. Once
-:command:`ipcluster` is configured properly, a user can start an IPython
+:command:`ipclusterz` is configured properly, a user can start an IPython
 cluster from their local workstation almost instantly, without having to log
 on to the head node (as is typically required by Unix based job schedulers).
 This enables a user to move seamlessly between serial and parallel
 computations.
 
-In this section we show how to use :command:`ipcluster` to start an IPython
+In this section we show how to use :command:`ipclusterz` to start an IPython
 cluster using the Windows HPC Server 2008 job scheduler. To make sure that
-:command:`ipcluster` is installed and working properly, you should first try
+:command:`ipclusterz` is installed and working properly, you should first try
 to start an IPython cluster on your local host. To do this, open a Windows
 Command Prompt and type the following command::
 
-    ipcluster start -n 2
+    ipclusterz start -n 2
 
 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:: ipclusterz_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
 take advantage of multiple cores on your local computer. 
 
-Now that we have confirmed that :command:`ipcluster` is working properly, we
+Now that we have confirmed that :command:`ipclusterz` is working properly, we
 describe how to configure and run an IPython cluster on an actual compute
 cluster running Windows HPC Server 2008. Here is an outline of the needed
 steps:
 
-1. Create a cluster profile using: ``ipcluster create -p mycluster``
+1. Create a cluster profile using: ``ipclusterz create -p mycluster``
 
 2. Edit configuration files in the directory :file:`.ipython\\cluster_mycluster`
 
@@ -190,7 +194,7 b' Creating a cluster profile'
 In most cases, you will have to create a cluster profile to use IPython on a
 cluster. A cluster profile is a name (like "mycluster") that is associated
 with a particular cluster configuration. The profile name is used by
-:command:`ipcluster` when working with the cluster.
+:command:`ipclusterz` when working with the cluster.
 
 Associated with each cluster profile is a cluster directory. This cluster
 directory is a specially named directory (typically located in the
@@ -203,13 +207,13 b' security keys. The naming convention for cluster directories is:'
 To create a new cluster profile (named "mycluster") and the associated cluster
 directory, type the following command at the Windows Command Prompt::
 
-    ipcluster create -p mycluster
+    ipclusterz create -p mycluster
 
 The output of this command is shown in the screenshot below. Notice how
-:command:`ipcluster` prints out the location of the newly created cluster
+:command:`ipclusterz` prints out the location of the newly created cluster
 directory.
 
-.. image:: ipcluster_create.*
+.. image:: ipclusterz_create.*
 
 Configuring a cluster profile
 -----------------------------
@@ -217,24 +221,24 b' Configuring a cluster profile'
 Next, you will need to configure the newly created cluster profile by editing
 the following configuration files in the cluster directory:
 
-* :file:`ipcluster_config.py`
+* :file:`ipclusterz_config.py`
 * :file:`ipcontroller_config.py`
 * :file:`ipengine_config.py`
 
-When :command:`ipcluster` is run, these configuration files are used to 
+When :command:`ipclusterz` is run, these configuration files are used to 
 determine how the engines and controller will be started. In most cases,
 you will only have to set a few of the attributes in these files.
 
-To configure :command:`ipcluster` to use the Windows HPC job scheduler, you
+To configure :command:`ipclusterz` to use the Windows HPC job scheduler, you
 will need to edit the following attributes in the file
-:file:`ipcluster_config.py`::
+:file:`ipclusterz_config.py`::
 
-    # Set these at the top of the file to tell ipcluster to use the
+    # Set these at the top of the file to tell ipclusterz to use the
     # Windows HPC job scheduler.
     c.Global.controller_launcher = \
-        'IPython.kernel.launcher.WindowsHPCControllerLauncher'
+        'IPython.zmq.parallel.launcher.WindowsHPCControllerLauncher'
     c.Global.engine_launcher = \
-        'IPython.kernel.launcher.WindowsHPCEngineSetLauncher'
+        'IPython.zmq.parallel.launcher.WindowsHPCEngineSetLauncher'
 
     # Set these to the host name of the scheduler (head node) of your cluster.
     c.WindowsHPCControllerLauncher.scheduler = 'HEADNODE'
@@ -256,15 +260,15 b' Starting the cluster profile'
 Once a cluster profile has been configured, starting an IPython cluster using
 the profile is simple::
 
-    ipcluster start -p mycluster -n 32
+    ipclusterz start -p mycluster -n 32
 
-The ``-n`` option tells :command:`ipcluster` how many engines to start (in
+The ``-n`` option tells :command:`ipclusterz` how many engines to start (in
 this case 32). Stopping the cluster is as simple as typing Control-C.
 
 Using the HPC Job Manager
 -------------------------
 
-When ``ipcluster start`` is run the first time, :command:`ipcluster` creates
+When ``ipclusterz start`` is run the first time, :command:`ipclusterz` creates
 two XML job description files in the cluster directory:
 
 * :file:`ipcontroller_job.xml`
@@ -272,8 +276,8 b' two XML job description files in the cluster directory:'
 
 Once these files have been created, they can be imported into the HPC Job
 Manager application. Then, the controller and engines for that profile can be
-started using the HPC Job Manager directly, without using :command:`ipcluster`.
-However, anytime the cluster profile is re-configured, ``ipcluster start``
+started using the HPC Job Manager directly, without using :command:`ipclusterz`.
+However, anytime the cluster profile is re-configured, ``ipclusterz start``
 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.
@@ -297,9 +301,9 b' apply it to each element of an array of integers in parallel using the'
 
 .. sourcecode:: ipython
 
-    In [1]: from IPython.kernel.client import *
+    In [1]: from IPython.zmq.parallel.client import *
 
-    In [2]: mec = MultiEngineClient(profile='mycluster')
+    In [2]: c = MultiEngineClient(profile='mycluster')
 
     In [3]: mec.get_ids()
     Out[3]: [0, 1, 2, 3, 4, 5, 67, 8, 9, 10, 11, 12, 13, 14]