Tidy up references to ipclusterz in parallel examples.

docs/examples/parallel/plotting/plotting_frontend.py

@@ -1,61 +1,61 b''
 """An example of how to use IPython1 for plotting remote parallel data
 
 The two files plotting_frontend.py and plotting_backend.py go together.
 
 To run this example, first start the IPython controller and 4
 engines::
 
-    ipclusterz start -n 4
+    ipcluster start -n 4
 
 Then start ipython in pylab mode::
 
     ipython -pylab
     
 Then a simple "run plotting_frontend.py" in IPython will run the
 example.  When this is done, all the variables (such as number, downx, etc.)
 are available in IPython, so for example you can make additional plots.
 """
 from __future__ import print_function
 
 import numpy as N
 from pylab import *
 from IPython.parallel import Client
 
 # Connect to the cluster
 rc = Client()
 view = rc[:]
 
 # Run the simulation on all the engines
 view.run('plotting_backend.py')
 
 # Bring back the data. These are all AsyncResult objects
 number = view.pull('number')
 d_number = view.pull('d_number')
 downx = view.gather('downx')
 downy = view.gather('downy')
 downpx = view.gather('downpx')
 downpy = view.gather('downpy')
 
 # but we can still iterate through AsyncResults before they are done
 print("number: ", sum(number))
 print("downsampled number: ", sum(d_number))
 
 
 # Make a scatter plot of the gathered data
 # These calls to matplotlib could be replaced by calls to pygist or
 # another plotting package.
 figure(1)
 # wait for downx/y
 downx = downx.get()
 downy = downy.get()
 scatter(downx, downy)
 xlabel('x')
 ylabel('y')
 figure(2)
 # wait for downpx/y
 downpx = downpx.get()
 downpy = downpy.get()
 scatter(downpx, downpy)
 xlabel('px')
 ylabel('py')
 show()

docs/examples/parallel/task_profiler.py

@@ -1,71 +1,71 b''
 #!/usr/bin/env python
 """Test the performance of the task farming system.
 
 This script submits a set of tasks via a LoadBalancedView.  The tasks
 are basically just a time.sleep(t), where t is a random number between
 two limits that can be configured at the command line.  To run
 the script there must first be an IPython controller and engines running::
 
-    ipclusterz start -n 16
+    ipcluster start -n 16
 
 A good test to run with 16 engines is::
 
     python task_profiler.py -n 128 -t 0.01 -T 1.0
 
 This should show a speedup of 13-14x.  The limitation here is that the
 overhead of a single task is about 0.001-0.01 seconds.
 """
 import random, sys
 from optparse import OptionParser
 
 from IPython.utils.timing import time
 from IPython.parallel import Client
 
 def main():
     parser = OptionParser()
     parser.set_defaults(n=100)
     parser.set_defaults(tmin=1e-3)
     parser.set_defaults(tmax=1)
     parser.set_defaults(profile='default')
 
     parser.add_option("-n", type='int', dest='n',
         help='the number of tasks to run')
     parser.add_option("-t", type='float', dest='tmin',
         help='the minimum task length in seconds')
     parser.add_option("-T", type='float', dest='tmax',
         help='the maximum task length in seconds')
     parser.add_option("-p", '--profile', type='str', dest='profile',
         help="the cluster profile [default: 'default']")
 
     (opts, args) = parser.parse_args()
     assert opts.tmax >= opts.tmin, "tmax must not be smaller than tmin"
 
     rc = Client()
     view = rc.load_balanced_view()
     print(view)
     rc.block=True
     nengines = len(rc.ids)
     with rc[:].sync_imports():
         from IPython.utils.timing import time
 
     # the jobs should take a random time within a range
     times = [random.random()*(opts.tmax-opts.tmin)+opts.tmin for i in range(opts.n)]
     stime = sum(times)
 
     print("executing %i tasks, totalling %.1f secs on %i engines"%(opts.n, stime, nengines))
     time.sleep(1)
     start = time.time()
     amr = view.map(time.sleep, times)
     amr.get()
     stop = time.time()
 
     ptime = stop-start
     scale = stime/ptime
 
     print("executed %.1f secs in %.1f secs"%(stime, ptime))
     print("%.3fx parallel performance on %i engines"%(scale, nengines))
     print("%.1f%% of theoretical max"%(100*scale/nengines))
 
 
 if __name__ == '__main__':
     main()