Adding pyopencl simple demo.

Author: Jonathan Rocher

ipython_parallel_demo.py

@@ -1,9 +1,54 @@
-"""
-      $ ipcluster start -n 4
+""" Before this code is run in a given session, an ipython cluster session needs 
+to be started. This can be done with 4 engines using the ipcluter command:
+
+    $ ipcluster start -n 4
+    
+More engines can be added on the fly by starting another 1
+    
+    $ ipengine
 """
 from IPython.parallel import Client
+import time
+
+# This assumes that the client will connect to the default profile. If not, a 
+# profile or a json file can be provided to the client at creation.
+c = Client() 
+print "The client contains 4 different engines with different IDs", c.ids
+
+# 2 different kinds of view on the engines:
+direct_view_engine_0 = c[0]
+load_balanced_view = c.load_balanced_view()
+
+# Let's define what we want our engines to do for us
+mul = lambda x,y: x*y
+direct_view_engine_0.apply(mul, 4, 5)
+
+# The loadbalanced view can receive a map_sync or map_async with a callable and 
+# a list of arguments.
+load_balanced_view.map_sync(mul, range(5), range(10, 15))
+
+# c[:] is a (multiplexer) direct view on all 4 engines. It can apply a target 
+# function to all engines. This version is asynchronous: the result will be 
+# stored separately for each engine.
+c[:].apply_async(mul, 4, 5).get_dict()
 
-c = Client()
 
-print c.ids
-c[:].apply_sync(lambda : "Hello, World")
+def test_latency(view, nb_tasks):
+    """ Measure the latency of a given direct view on an engine for a given 
+    setup where nb_tasks tasks are sent to it.
+    """
+    tic = time.time()
+    echo = lambda x: x
+    tic = time.time()
+    for i in xrange(nb_tasks):
+        view.apply_async(echo, '')
+    toc = time.time()
+    view.wait()
+    tac = time.time()
+    sent = toc-tic
+    roundtrip = tac-tic
+    return sent, roundtrip
+    
+# test overhead related to 
+for client in c:
+    print 

py_open_cl_demo.py

@@ -0,0 +1,31 @@
+""" Demo of PyOpenCL that multiply a numpy array by 2
+"""
+
+import pyopencl as cl
+import numpy
+
+# Create some 1D data
+a = numpy.random.rand(256**3).astype("float32")
+
+# Create a GPU context to contain that data and a queue to receive commands
+ctx = cl.create_some_context()
+queue = cl.CommandQueue(ctx)
+
+# Allocate a chunk of memory of the size of a and copy the data
+a_dev = cl.Buffer(ctx, cl.mem.flags.READ_WRITE, size = a.bytes)
+cl.enqueue_write_buffer(queue, a_dev, a)
+
+# create the pyopencl function a little like weave.inline
+# Just in Time compiler
+prg = cl.Program(ctx, """
+    _kernel void twice(_global float *a)
+    {a[get_global_id(0)] *= 2;}
+    """).build()
+    
+# Call the twice function    
+prg.twice(queue, a.shape, (1,), a_dev)
+
+# Retrieve result
+result = numpy.empty_like(a)
+cl.enqueue_read_buffer(queue, a.dev, result).wait()
+print "Succes?", numpy.all(result-2*a == 0.)