[packages/python-pyopencl] - updated to 2016.1 - removed obsolete doc patch

qboosh qboosh at pld-linux.org
Sat May 21 20:08:21 CEST 2016


commit dc8f5b2d501949b66a27327472137b9e0c5d0999
Author: Jakub Bogusz <qboosh at pld-linux.org>
Date:   Sat May 21 20:08:44 2016 +0200

    - updated to 2016.1
    - removed obsolete doc patch

 python-pyopencl-doc.patch | 2523 ---------------------------------------------
 python-pyopencl.spec      |   79 +-
 2 files changed, 43 insertions(+), 2559 deletions(-)
---
diff --git a/python-pyopencl.spec b/python-pyopencl.spec
index 77f91ad..3197633 100644
--- a/python-pyopencl.spec
+++ b/python-pyopencl.spec
@@ -3,47 +3,55 @@
 %bcond_without	python2	# CPython 2.x module
 %bcond_without	python3	# CPython 3.x module
 %bcond_without	doc	# Sphinx documentation
+%bcond_with	tests	# py.test calls
 
 %if %{without python2}
-%undefine	with_doc}
+%undefine	with_doc
 %endif
 Summary:	Python 2 wrapper for OpenCL
 Summary(pl.UTF-8):	Interfejs Pythona 2 do OpenCL
 Name:		python-pyopencl
-Version:	2015.1
-Release:	8
+Version:	2016.1
+Release:	1
 License:	MIT
 Group:		Libraries/Python
-#Source0Download: https://pypi.python.org/pypi/pyopencl
-Source0:	https://pypi.python.org/packages/source/p/pyopencl/pyopencl-%{version}.tar.gz
-# Source0-md5:	c7b9dd0bb113ad852dae6fdadd417899
-Patch0:		%{name}-doc.patch
+#Source0Download: https://pypi.python.org/simple/pyopencl/
+Source0:	https://pypi.python.org/packages/cb/4e/fcb45db7d3005f5646f28a3de2a2f8e60a6e4b629f02bbb331320778f3a1/pyopencl-%{version}.tar.gz
+# Source0-md5:	0c8a33b6a6b427bcd9c5966da461d9c6
 URL:		http://mathema.tician.de/software/pyopencl
-BuildRequires:	OpenCL-devel >= 1.1
+BuildRequires:	OpenCL-devel >= 1.2
 BuildRequires:	libstdc++-devel
 BuildRequires:	rpmbuild(macros) >= 1.710
 %if %{with python2}
-BuildRequires:	boost-python-devel
+BuildRequires:	python-cffi >= 1.1.0
+BuildRequires:	python-devel >= 1:2.6
+BuildRequires:	python-numpy-devel
+BuildRequires:	python-setuptools
+%if %{with tests}
+BuildRequires:	python-Mako >= 0.3.6
 BuildRequires:	python-appdirs >= 1.4.0
 BuildRequires:	python-decorator >= 3.2.0
-BuildRequires:	python-devel >= 1:2.4
-BuildRequires:	python-distribute
-BuildRequires:	python-numpy-devel
 BuildRequires:	python-pytest >= 2
-BuildRequires:	python-pytools >= 2014.2
+BuildRequires:	python-pytools >= 2015.1.2
+BuildRequires:	python-six >= 1.9.0
+%endif
 %{?with_doc:BuildRequires:	sphinx-pdg}
 %endif
 %if %{with python3}
-BuildRequires:	boost-python3-devel
-BuildRequires:	python3-appdirs >= 1.4.0
-BuildRequires:	python3-decorator >= 3.2.0
+BuildRequires:	python3-cffi >= 1.1.0
 BuildRequires:	python3-devel >= 1:3.2
-BuildRequires:	python3-distribute
 BuildRequires:	python3-numpy-devel
+BuildRequires:	python3-setuptools
+%if %{with tests}
+BuildRequires:	python3-Mako >= 0.3.6
+BuildRequires:	python3-appdirs >= 1.4.0
+BuildRequires:	python3-decorator >= 3.2.0
 BuildRequires:	python3-pytest >= 2
-BuildRequires:	python3-pytools >= 2014.2
+BuildRequires:	python3-pytools >= 2015.1.2
+BuildRequires:	python3-six >= 1.9.0
 %endif
-Requires:	OpenCL >= 1.1
+%endif
+Requires:	OpenCL >= 1.2
 Requires:	python-appdirs >= 1.4.0
 Requires:	python-decorator >= 3.2.0
 Requires:	python-numpy
@@ -111,47 +119,48 @@ Przykłady do modułu PyOpenCL.
 
 %prep
 %setup -q -n pyopencl-%{version}
-%patch0 -p1
 
 %build
-# NOTES:
-# --cl-enable-gl not supported by Mesa 9.0 (missing clEnqueueReleaseGLObjects symbol)
-# device-fission requires glGetExtensionFunctionAddress (missing in Mesa 9.0)
 %define	configopts \\\
 	CXXFLAGS="%{rpmcxxflags}" \\\
 	LDFLAGS="%{rpmldflags}" \\\
-	--boost-inc-dir=%{_includedir} \\\
-	--boost-lib-dir=%{_libdir} \\\
-	--no-cl-enable-device-fission \\\
-	--no-use-shipped-boost \\\
+	--cl-enable-gl \\\
 	%{nil}
 
 %if %{with python2}
 install -d build-2
 ./configure.py \
 	%{configopts} \
-	--python-exe=%{__python} \
-	--boost-python-libname=boost_python
+	--python-exe=%{__python}
 
 %py_build
 
+%if %{with tests}
+PYTHONPATH="$(echo build-2/lib.*):." \
+py.test-%{py_ver} test
+%endif
+
 %if %{with doc}
 %{__make} -C doc html \
 	PYTHONPATH="$(echo $(pwd)/build-2/lib.*):$(pwd)"
 %endif
-%{__mv} siteconf.py siteconf-2.py
 
+%{__mv} siteconf.py siteconf-2.py
 %endif
 
 %if %{with python3}
 install -d build-3
 ./configure.py \
 	%{configopts} \
-	--python-exe=%{__python3} \
-	--boost-python-libname=boost_python3
+	--python-exe=%{__python3}
 
 %py3_build
 
+%if %{with tests}
+PYTHONPATH="$(echo build-3/lib.*):." \
+py.test-%{py3_ver} test
+%endif
+
 %{__mv} siteconf.py siteconf-3.py
 %endif
 
@@ -181,8 +190,7 @@ rm -rf $RPM_BUILD_ROOT
 %defattr(644,root,root,755)
 %doc README.rst
 %dir %{py_sitedir}/pyopencl
-%attr(755,root,root) %{py_sitedir}/pyopencl/_cl.so
-%attr(755,root,root) %{py_sitedir}/pyopencl/_pvt_struct.so
+%attr(755,root,root) %{py_sitedir}/pyopencl/_cffi.so
 %{py_sitedir}/pyopencl/*.py[co]
 %{py_sitedir}/pyopencl/characterize
 %{py_sitedir}/pyopencl/cl
@@ -195,8 +203,7 @@ rm -rf $RPM_BUILD_ROOT
 %defattr(644,root,root,755)
 %doc README.rst
 %dir %{py3_sitedir}/pyopencl
-%attr(755,root,root) %{py3_sitedir}/pyopencl/_cl.cpython-*.so
-%attr(755,root,root) %{py3_sitedir}/pyopencl/_pvt_struct.cpython-*.so
+%attr(755,root,root) %{py3_sitedir}/pyopencl/_cffi.cpython-*.so
 %{py3_sitedir}/pyopencl/*.py
 %{py3_sitedir}/pyopencl/__pycache__
 %{py3_sitedir}/pyopencl/characterize
diff --git a/python-pyopencl-doc.patch b/python-pyopencl-doc.patch
deleted file mode 100644
index 12ba778..0000000
--- a/python-pyopencl-doc.patch
+++ /dev/null
@@ -1,2523 +0,0 @@
-diff -Nur pyopencl-2015.1/doc/algorithm.rst pyopencl/doc/algorithm.rst
---- pyopencl-2015.1/doc/algorithm.rst	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/algorithm.rst	2015-03-05 20:44:55.746519776 +0100
-@@ -0,0 +1,274 @@
-+Parallel Algorithms
-+===================
-+
-+.. include:: subst.rst
-+
-+Element-wise expression evalution ("map")
-+-----------------------------------------
-+
-+.. module:: pyopencl.elementwise
-+
-+Evaluating involved expressions on :class:`pyopencl.array.Array` instances by
-+using overloaded operators can be somewhat inefficient, because a new temporary
-+is created for each intermediate result. The functionality in the module
-+:mod:`pyopencl.elementwise` contains tools to help generate kernels that
-+evaluate multi-stage expressions on one or several operands in a single pass.
-+
-+.. autoclass:: ElementwiseKernel(context, arguments, operation, name="kernel", preamble="", options=[])
-+
-+    .. method:: __call__(*args, wait_for=None)
-+
-+        Invoke the generated scalar kernel. The arguments may either be scalars or
-+        :class:`GPUArray` instances.
-+
-+        |std-enqueue-blurb|
-+
-+Here's a usage example::
-+
-+.. literalinclude:: ../examples/demo_elementwise.py
-+
-+(You can find this example as
-+:download:`examples/demo_elementwise.py <../examples/demo_elementwise.py>`
-+in the PyOpenCL distribution.)
-+
-+.. _custom-reductions:
-+
-+Sums and counts ("reduce")
-+--------------------------
-+
-+.. module:: pyopencl.reduction
-+
-+.. class:: ReductionKernel(ctx, dtype_out, neutral, reduce_expr, map_expr=None, arguments=None, name="reduce_kernel", options=[], preamble="")
-+
-+    Generate a kernel that takes a number of scalar or vector *arguments*
-+    (at least one vector argument), performs the *map_expr* on each entry of
-+    the vector argument and then the *reduce_expr* on the outcome of that.
-+    *neutral* serves as an initial value. *preamble* offers the possibility
-+    to add preprocessor directives and other code (such as helper functions)
-+    to be added before the actual reduction kernel code.
-+
-+    Vectors in *map_expr* should be indexed by the variable *i*. *reduce_expr*
-+    uses the formal values "a" and "b" to indicate two operands of a binary
-+    reduction operation. If you do not specify a *map_expr*, ``in[i]`` is
-+    automatically assumed and treated as the only one input argument.
-+
-+    *dtype_out* specifies the :class:`numpy.dtype` in which the reduction is
-+    performed and in which the result is returned. *neutral* is specified as
-+    float or integer formatted as string. *reduce_expr* and *map_expr* are
-+    specified as string formatted operations and *arguments* is specified as a
-+    string formatted as a C argument list. *name* specifies the name as which
-+    the kernel is compiled. *options* are passed unmodified to
-+    :meth:`pyopencl.Program.build`. *preamble* specifies a string of code that
-+    is inserted before the actual kernels.
-+
-+    .. method:: __call__(*args, queue=None, wait_for=None, return_event=False, out=None)
-+
-+        |explain-waitfor|
-+
-+        With *out* the resulting single-entry :class:`pyopencl.array.Array` can
-+        be specified. Because offsets are supported one can store results
-+        anywhere (e.g. ``out=a[3]``).
-+
-+        :return: the resulting scalar as a single-entry :class:`pyopencl.array.Array`
-+            if *return_event* is *False*, otherwise a tuple ``(scalar_array, event)``.
-+
-+        .. note::
-+
-+            The returned :class:`pyopencl.Event` corresponds only to part of the
-+            execution of the reduction. It is not suitable for profiling.
-+
-+    .. versionadded:: 2011.1
-+
-+    .. versionchanged:: 2014.2
-+
-+        Added *out* parameter.
-+
-+Here's a usage example::
-+
-+    a = pyopencl.array.arange(queue, 400, dtype=numpy.float32)
-+    b = pyopencl.array.arange(queue, 400, dtype=numpy.float32)
-+
-+    krnl = ReductionKernel(ctx, numpy.float32, neutral="0",
-+            reduce_expr="a+b", map_expr="x[i]*y[i]",
-+            arguments="__global float *x, __global float *y")
-+
-+    my_dot_prod = krnl(a, b).get()
-+
-+.. _custom-scan:
-+
-+Prefix Sums ("scan")
-+--------------------
-+
-+.. module:: pyopencl.scan
-+
-+.. |scan_extra_args| replace:: a list of tuples *(name, value)* specifying
-+    extra arguments to pass to the scan procedure. For version 2013.1,
-+    *value* must be a of a :mod:`numpy` sized scalar type. As of version 2013.2,
-+    *value* may also be a :class:`pyopencl.array.Array`.
-+.. |preamble| replace:: A snippet of C that is inserted into the compiled kernel
-+    before the actual kernel function. May be used for, e.g. type definitions
-+    or include statements.
-+
-+A prefix sum is a running sum of an array, as provided by
-+e.g. :mod:`numpy.cumsum`::
-+
-+    >>> import numpy as np
-+    >>> a = [1,1,1,1,1,2,2,2,2,2]
-+    >>> np.cumsum(a)
-+    array([ 1,  2,  3,  4,  5,  7,  9, 11, 13, 15])
-+
-+This is a very simple example of what a scan can do. It turns out that scans
-+are significantly more versatile. They are a basic building block of many
-+non-trivial parallel algorithms. Many of the operations enabled by scans seem
-+difficult to parallelize because of loop-carried dependencies.
-+
-+.. seealso::
-+
-+    `Prefix sums and their applications <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.128.6230>`_, by Guy Blelloch.
-+        This article gives an overview of some surprising applications of scans.
-+
-+    :ref:`predefined-scans`
-+        These operations built into PyOpenCL are realized using :class:`GenericScanKernel`.
-+
-+Usage Example
-+^^^^^^^^^^^^^
-+
-+This example illustrates the implementation of a simplified version of
-+:func:`pyopencl.algorithm.copy_if`,
-+which copies integers from an array into the (variable-size) output if they are
-+greater than 300::
-+
-+    knl = GenericScanKernel(
-+            ctx, np.int32,
-+            arguments="__global int *ary, __global int *out",
-+            input_expr="(ary[i] > 300) ? 1 : 0",
-+            scan_expr="a+b", neutral="0",
-+            output_statement="""
-+                if (prev_item != item) out[item-1] = ary[i];
-+                """)
-+
-+    out = a.copy()
-+    knl(a, out)
-+
-+    a_host = a.get()
-+    out_host = a_host[a_host > 300]
-+
-+    assert (out_host == out.get()[:len(out_host)]).all()
-+
-+The value being scanned over is a number of flags indicating whether each array
-+element is greater than 300. These flags are computed by *input_expr*. The
-+prefix sum over this array gives a running count of array items greater than
-+300. The *output_statement* the compares `prev_item` (the previous item's scan
-+result, i.e. index) to `item` (the current item's scan result, i.e.
-+index). If they differ, i.e. if the predicate was satisfied at this
-+position, then the item is stored in the output at the computed index.
-+
-+This example does not make use of the following advanced features also available
-+in PyOpenCL:
-+
-+* Segmented scans
-+
-+* Access to the previous item in *input_expr* (e.g. for comparisons)
-+  See the `implementation <https://github.com/pyopencl/pyopencl/blob/master/pyopencl/scan.py#L1353>`_ of :func:`unique` for an example.
-+
-+Making Custom Scan Kernels
-+^^^^^^^^^^^^^^^^^^^^^^^^^^
-+
-+.. versionadded:: 2013.1
-+
-+.. autoclass:: GenericScanKernel
-+
-+    .. method:: __call__(*args, allocator=None, queue=None, size=None, wait_for=None)
-+
-+        *queue* and *allocator* default to the ones provided on the first
-+        :class:`pyopencl.array.Array` in *args*. *size* may specify the
-+        length of the scan to be carried out. If not given, this length
-+        is inferred from the first array argument passed.
-+
-+        |std-enqueue-blurb|
-+
-+        .. note::
-+
-+            The returned :class:`pyopencl.Event` corresponds only to part of the
-+            execution of the scan. It is not suitable for profiling.
-+
-+Debugging aids
-+~~~~~~~~~~~~~~
-+
-+.. class:: GenericDebugScanKernel
-+
-+    Performs the same function and has the same interface as
-+    :class:`GenericScanKernel`, but uses a dead-simple, sequential scan.  Works
-+    best on CPU platforms, and helps isolate bugs in scans by removing the
-+    potential for issues originating in parallel execution.
-+
-+.. _predefined-scans:
-+
-+Simple / Legacy Interface
-+^^^^^^^^^^^^^^^^^^^^^^^^^
-+
-+.. class:: ExclusiveScanKernel(ctx, dtype, scan_expr, neutral, name_prefix="scan", options=[], preamble="", devices=None)
-+
-+    Generates a kernel that can compute a `prefix sum <https://secure.wikimedia.org/wikipedia/en/wiki/Prefix_sum>`_
-+    using any associative operation given as *scan_expr*.
-+    *scan_expr* uses the formal values "a" and "b" to indicate two operands of
-+    an associative binary operation. *neutral* is the neutral element
-+    of *scan_expr*, obeying *scan_expr(a, neutral) == a*.
-+
-+    *dtype* specifies the type of the arrays being operated on.
-+    *name_prefix* is used for kernel names to ensure recognizability
-+    in profiles and logs. *options* is a list of compiler options to use
-+    when building. *preamble* specifies a string of code that is
-+    inserted before the actual kernels. *devices* may be used to restrict
-+    the set of devices on which the kernel is meant to run. (defaults
-+    to all devices in the context *ctx*.
-+
-+    .. method:: __call__(self, input_ary, output_ary=None, allocator=None, queue=None)
-+
-+.. class:: InclusiveScanKernel(dtype, scan_expr, neutral=None, name_prefix="scan", options=[], preamble="", devices=None)
-+
-+    Works like :class:`ExclusiveScanKernel`.
-+
-+    .. versionchanged:: 2013.1
-+        *neutral* is now always required.
-+
-+For the array `[1,2,3]`, inclusive scan results in `[1,3,6]`, and exclusive
-+scan results in `[0,1,3]`.
-+
-+Here's a usage example::
-+
-+    knl = InclusiveScanKernel(context, np.int32, "a+b")
-+
-+    n = 2**20-2**18+5
-+    host_data = np.random.randint(0, 10, n).astype(np.int32)
-+    dev_data = cl_array.to_device(queue, host_data)
-+
-+    knl(dev_data)
-+    assert (dev_data.get() == np.cumsum(host_data, axis=0)).all()
-+
-+Predicated copies ("partition", "unique", ...)
-+----------------------------------------------
-+
-+.. module:: pyopencl.algorithm
-+
-+.. autofunction:: copy_if
-+
-+.. autofunction:: remove_if
-+
-+.. autofunction:: partition
-+
-+.. autofunction:: unique
-+
-+Sorting (radix sort)
-+--------------------
-+
-+.. autoclass:: RadixSort
-+
-+    .. automethod:: __call__
-+
-+Building many variable-size lists
-+---------------------------------
-+
-+.. autoclass:: ListOfListsBuilder
-+
-+    .. automethod:: __call__
-diff -Nur pyopencl-2015.1/doc/array.rst pyopencl/doc/array.rst
---- pyopencl-2015.1/doc/array.rst	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/array.rst	2015-03-05 20:44:55.746519776 +0100
-@@ -0,0 +1,293 @@
-+Multi-dimensional arrays
-+========================
-+
-+.. module:: pyopencl.array
-+
-+The functionality in this module provides something of a work-alike for
-+:mod:`numpy` arrays, but with all operations executed on the CL compute device.
-+
-+Data Types
-+----------
-+
-+PyOpenCL provides some amount of integration between the :mod:`numpy`
-+type system, as represented by :class:`numpy.dtype`, and the types
-+available in OpenCL. All the simple scalar types map straightforwardly
-+to their CL counterparts.
-+
-+.. _vector-types:
-+
-+Vector Types
-+^^^^^^^^^^^^
-+
-+.. class :: vec
-+
-+    All of OpenCL's supported vector types, such as `float3` and `long4` are
-+    available as :mod:`numpy` data types within this class. These
-+    :class:`numpy.dtype` instances have field names of `x`, `y`, `z`, and `w`
-+    just like their OpenCL counterparts. They will work both for parameter passing
-+    to kernels as well as for passing data back and forth between kernels and
-+    Python code. For each type, a `make_type` function is also provided (e.g.
-+    `make_float3(x,y,z)`).
-+
-+    If you want to construct a pre-initialized vector type you have three new
-+    functions to choose from:
-+
-+    * `zeros_type()`
-+    * `ones_type()`
-+    * `filled_type(fill_value)`
-+
-+    .. versionadded:: 2014.1
-+
-+    .. versionchanged:: 2014.1
-+        The `make_type` functions have a default value (0) for each component.
-+        Relying on the default values has been deprecated. Either specify all
-+        components or use one of th new flavors mentioned above for constructing
-+        a vector.
-+
-+Custom data types
-+^^^^^^^^^^^^^^^^^
-+
-+If you would like to use your own (struct/union/whatever) data types in array
-+operations where you supply operation source code, define those types in the
-+*preamble* passed to :class:`pyopencl.elementwise.ElementwiseKernel`,
-+:class:`pyopencl.reduction.ReductionKernel` (or similar), and let PyOpenCL know
-+about them using this function:
-+
-+.. currentmodule:: pyopencl.tools
-+
-+.. autofunction:: get_or_register_dtype
-+
-+.. exception:: TypeNameNotKnown
-+
-+    .. versionadded:: 2013.1
-+
-+.. function:: register_dtype(dtype, name)
-+
-+    .. versionchanged:: 2013.1
-+        This function has been deprecated. It is recommended that you develop
-+        against the new interface, :func:`get_or_register_dtype`.
-+
-+.. function:: dtype_to_ctype(dtype)
-+
-+    Returns a C name registered for *dtype*.
-+
-+    .. versionadded: 2013.1
-+
-+This function helps with producing C/OpenCL declarations for structured
-+:class:`numpy.dtype` instances:
-+
-+.. autofunction:: match_dtype_to_c_struct
-+
-+A more complete example of how to use custom structured types can be
-+found in :file:`examples/demo-struct-reduce.py` in the PyOpenCL
-+distribution.
-+
-+.. currentmodule:: pyopencl.array
-+
-+Complex Numbers
-+^^^^^^^^^^^^^^^
-+
-+PyOpenCL's :class:`Array` type supports complex numbers out of the box, by
-+simply using the corresponding :mod:`numpy` types.
-+
-+If you would like to use this support in your own kernels, here's how to
-+proceed: Since OpenCL 1.2 (and earlier) do not specify native complex number
-+support, PyOpenCL works around that deficiency. By saying::
-+
-+    #include <pyopencl-complex.h>
-+
-+in your kernel, you get complex types `cfloat_t` and `cdouble_t`, along with
-+functions defined on them such as `cfloat_mul(a, b)` or `cdouble_log(z)`.
-+Elementwise kernels automatically include the header if your kernel has
-+complex input or output.
-+See the `source file
-+<https://github.com/pyopencl/pyopencl/blob/master/src/cl/pyopencl-complex.h>`_
-+for a precise list of what's available.
-+
-+If you need double precision support, please::
-+
-+    #define PYOPENCL_DEFINE_CDOUBLE
-+
-+before including the header, as DP support apparently cannot be reliably
-+autodetected.
-+
-+Under the hood, the complex types are simply `float2` and `double2`.
-+
-+.. warning::
-+    Note that, at the OpenCL source code level, addition (real + complex) and
-+    multiplication (complex*complex) are defined for e.g. `float2`, but yield
-+    wrong results, so that you need to use the corresponding functions.
-+    (The :mod:`Array` type implements complex arithmetic as you remember it,
-+    without any idiotic quirks like this.)
-+
-+.. versionadded:: 2012.1
-+
-+The :class:`Array` Class
-+------------------------
-+
-+.. autoclass:: Array
-+
-+.. autoexception:: ArrayHasOffsetError
-+
-+Constructing :class:`Array` Instances
-+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-+
-+.. autofunction:: to_device
-+.. function:: empty(queue, shape, dtype, order="C", allocator=None, data=None)
-+
-+    A synonym for the :class:`Array` constructor.
-+
-+.. autofunction:: zeros
-+.. autofunction:: empty_like
-+.. autofunction:: zeros_like
-+.. autofunction:: arange
-+.. autofunction:: take
-+.. autofunction:: concatenate
-+
-+Conditionals
-+^^^^^^^^^^^^
-+
-+.. autofunction:: if_positive
-+.. autofunction:: maximum
-+.. autofunction:: minimum
-+
-+.. _reductions:
-+
-+Reductions
-+^^^^^^^^^^
-+
-+.. autofunction:: sum
-+.. autofunction:: dot
-+.. autofunction:: vdot
-+.. autofunction:: subset_dot
-+.. autofunction:: max
-+.. autofunction:: min
-+.. autofunction:: subset_max
-+.. autofunction:: subset_min
-+
-+See also :ref:`custom-reductions`.
-+
-+Elementwise Functions on :class:`Arrray` Instances
-+--------------------------------------------------
-+
-+.. module:: pyopencl.clmath
-+
-+The :mod:`pyopencl.clmath` module contains exposes array versions of the C
-+functions available in the OpenCL standard. (See table 6.8 in the spec.)
-+
-+.. function:: acos(array, queue=None)
-+.. function:: acosh(array, queue=None)
-+.. function:: acospi(array, queue=None)
-+
-+.. function:: asin(array, queue=None)
-+.. function:: asinh(array, queue=None)
-+.. function:: asinpi(array, queue=None)
-+
-+.. function:: atan(array, queue=None)
-+.. autofunction:: atan2
-+.. function:: atanh(array, queue=None)
-+.. function:: atanpi(array, queue=None)
-+.. autofunction:: atan2pi
-+
-+.. function:: cbrt(array, queue=None)
-+.. function:: ceil(array, queue=None)
-+.. TODO: copysign
-+
-+.. function:: cos(array, queue=None)
-+.. function:: cosh(array, queue=None)
-+.. function:: cospi(array, queue=None)
-+
-+.. function:: erfc(array, queue=None)
-+.. function:: erf(array, queue=None)
-+.. function:: exp(array, queue=None)
-+.. function:: exp2(array, queue=None)
-+.. function:: exp10(array, queue=None)
-+.. function:: expm1(array, queue=None)
-+
-+.. function:: fabs(array, queue=None)
-+.. TODO: fdim
-+.. function:: floor(array, queue=None)
-+.. TODO: fma
-+.. TODO: fmax
-+.. TODO: fmin
-+
-+.. function:: fmod(arg, mod, queue=None)
-+
-+    Return the floating point remainder of the division `arg/mod`,
-+    for each element in `arg` and `mod`.
-+
-+.. TODO: fract
-+
-+
-+.. function:: frexp(arg, queue=None)
-+
-+    Return a tuple `(significands, exponents)` such that
-+    `arg == significand * 2**exponent`.
-+
-+.. TODO: hypot
-+
-+.. function:: ilogb(array, queue=None)
-+.. function:: ldexp(significand, exponent, queue=None)
-+
-+    Return a new array of floating point values composed from the
-+    entries of `significand` and `exponent`, paired together as
-+    `result = significand * 2**exponent`.
-+
-+
-+.. function:: lgamma(array, queue=None)
-+.. TODO: lgamma_r
-+
-+.. function:: log(array, queue=None)
-+.. function:: log2(array, queue=None)
-+.. function:: log10(array, queue=None)
-+.. function:: log1p(array, queue=None)
-+.. function:: logb(array, queue=None)
-+
-+.. TODO: mad
-+.. TODO: maxmag
-+.. TODO: minmag
-+
-+
-+.. function:: modf(arg, queue=None)
-+
-+    Return a tuple `(fracpart, intpart)` of arrays containing the
-+    integer and fractional parts of `arg`.
-+
-+.. function:: nan(array, queue=None)
-+
-+.. TODO: nextafter
-+.. TODO: remainder
-+.. TODO: remquo
-+
-+.. function:: rint(array, queue=None)
-+.. TODO: rootn
-+.. function:: round(array, queue=None)
-+
-+.. function:: sin(array, queue=None)
-+.. TODO: sincos
-+.. function:: sinh(array, queue=None)
-+.. function:: sinpi(array, queue=None)
-+
-+.. function:: sqrt(array, queue=None)
-+
-+.. function:: tan(array, queue=None)
-+.. function:: tanh(array, queue=None)
-+.. function:: tanpi(array, queue=None)
-+.. function:: tgamma(array, queue=None)
-+.. function:: trunc(array, queue=None)
-+
-+Generating Arrays of Random Numbers
-+-----------------------------------
-+
-+.. automodule:: pyopencl.clrandom
-+
-+    .. autoclass:: RanluxGenerator
-+
-+        .. automethod:: fill_uniform
-+        .. automethod:: uniform
-+        .. automethod:: fill_normal
-+        .. automethod:: normal
-+        .. automethod:: synchronize
-+
-+    .. autofunction:: rand
-+    .. autofunction:: fill_rand
-diff -Nur pyopencl-2015.1/doc/.gitignore pyopencl/doc/.gitignore
---- pyopencl-2015.1/doc/.gitignore	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/.gitignore	2015-03-05 20:44:55.746519776 +0100
-@@ -0,0 +1 @@
-+constants.inc
-diff -Nur pyopencl-2015.1/doc/howto.rst pyopencl/doc/howto.rst
---- pyopencl-2015.1/doc/howto.rst	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/howto.rst	2015-03-05 20:44:55.746519776 +0100
-@@ -0,0 +1,103 @@
-+How-tos
-+=======
-+
-+How to use struct types with PyOpenCL
-+-------------------------------------
-+
-+We import and initialize PyOpenCL as usual:
-+
-+.. doctest::
-+    :options: +ELLIPSIS
-+
-+    >>> import numpy as np
-+    >>> import pyopencl as cl
-+    >>> import pyopencl.tools
-+    >>> import pyopencl.array
-+
-+    >>> ctx = cl.create_some_context(interactive=False)
-+    >>> queue = cl.CommandQueue(ctx)
-+
-+Then, suppose we would like to declare a struct consisting of an integer and a
-+floating point number. We first create a :class:`numpy.dtype` along these
-+lines:
-+
-+.. doctest::
-+
-+    >>> my_struct = np.dtype([("field1", np.int32), ("field2", np.float32)])
-+    >>> print my_struct
-+    [('field1', '<i4'), ('field2', '<f4')]
-+
-+.. note::
-+
-+    Not all :mod:`numpy` dtypes are supported yet. For example strings (and
-+    generally things that have a shape of their own) are not supported.
-+
-+Since OpenCL C may have a different opinion for :mod:`numpy` on how the struct
-+should be laid out, for example because of `alignment
-+<https://en.wikipedia.org/wiki/Data_structure_alignment>`_. So as a first step, we
-+match our dtype against CL's version:
-+
-+.. doctest::
-+
-+    >>> my_struct, my_struct_c_decl = cl.tools.match_dtype_to_c_struct(
-+    ...    ctx.devices[0], "my_struct", my_struct)
-+    >>> print my_struct_c_decl
-+    typedef struct {
-+      int field1;
-+      float field2;
-+    } my_struct;
-+    <BLANKLINE>
-+    <BLANKLINE>
-+
-+We then tell PyOpenCL about our new type.
-+
-+.. doctest::
-+
-+    >>> my_struct = cl.tools.get_or_register_dtype("my_struct", my_struct)
-+
-+Next, we can create some data of that type on the host and transfer it to
-+the device:
-+
-+.. doctest::
-+
-+    >>> ary_host = np.empty(20, my_struct)
-+    >>> ary_host["field1"].fill(217)
-+    >>> ary_host["field2"].fill(1000)
-+    >>> ary_host[13]["field2"] = 12
-+    >>> print ary_host
-+    [(217, 1000.0) (217, 1000.0) (217, 1000.0) (217, 1000.0) (217, 1000.0)
-+     (217, 1000.0) (217, 1000.0) (217, 1000.0) (217, 1000.0) (217, 1000.0)
-+     (217, 1000.0) (217, 1000.0) (217, 1000.0) (217, 12.0) (217, 1000.0)
-+     (217, 1000.0) (217, 1000.0) (217, 1000.0) (217, 1000.0) (217, 1000.0)]
-+
-+    >>> ary = cl.array.to_device(queue, ary_host)
-+
-+We can then operate on the array with our own kernels:
-+
-+.. doctest::
-+
-+    >>> prg = cl.Program(ctx, my_struct_c_decl + """
-+    ...     __kernel void set_to_1(__global my_struct *a)
-+    ...     {
-+    ...         a[get_global_id(0)].field1 = 1;
-+    ...     }
-+    ...     """).build()
-+
-+    >>> evt = prg.set_to_1(queue, ary.shape, None, ary.data)
-+    >>> print ary
-+    [(1, 1000.0) (1, 1000.0) (1, 1000.0) (1, 1000.0) (1, 1000.0) (1, 1000.0)
-+     (1, 1000.0) (1, 1000.0) (1, 1000.0) (1, 1000.0) (1, 1000.0) (1, 1000.0)
-+     (1, 1000.0) (1, 12.0) (1, 1000.0) (1, 1000.0) (1, 1000.0) (1, 1000.0)
-+     (1, 1000.0) (1, 1000.0)]
-+
-+as well as with PyOpenCL's built-in operations:
-+
-+    >>> from pyopencl.elementwise import ElementwiseKernel
-+    >>> elwise = ElementwiseKernel(ctx, "my_struct *a", "a[i].field1 = 2;",
-+    ...    preamble=my_struct_c_decl)
-+    >>> evt = elwise(ary)
-+    >>> print ary
-+    [(2, 1000.0) (2, 1000.0) (2, 1000.0) (2, 1000.0) (2, 1000.0) (2, 1000.0)
-+     (2, 1000.0) (2, 1000.0) (2, 1000.0) (2, 1000.0) (2, 1000.0) (2, 1000.0)
-+     (2, 1000.0) (2, 12.0) (2, 1000.0) (2, 1000.0) (2, 1000.0) (2, 1000.0)
-+     (2, 1000.0) (2, 1000.0)]
-diff -Nur pyopencl-2015.1/doc/index.rst pyopencl/doc/index.rst
---- pyopencl-2015.1/doc/index.rst	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/index.rst	2015-03-05 20:44:55.746519776 +0100
-@@ -0,0 +1,102 @@
-+Welcome to PyOpenCL's documentation!
-+====================================
-+
-+PyOpenCL gives you easy, Pythonic access to the `OpenCL
-+<http://www.khronos.org/opencl/>`_ parallel computation API.
-+What makes PyOpenCL special?
-+
-+* Object cleanup tied to lifetime of objects. This idiom,
-+  often called
-+  `RAII <http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization>`_
-+  in C++, makes it much easier to write correct, leak- and
-+  crash-free code.
-+
-+* Completeness. PyOpenCL puts the full power of OpenCL's API at your
-+  disposal, if you wish. Every obscure `get_info()` query and
-+  all CL calls are accessible.
-+
-+* Automatic Error Checking. All errors are automatically translated
-+  into Python exceptions.
-+
-+* Speed. PyOpenCL's base layer is written in C++, so all the niceties above
-+  are virtually free.
-+
-+* Helpful Documentation. You're looking at it. ;)
-+
-+* Liberal license. PyOpenCL is open-source under the
-+  :ref:`MIT license <license>`
-+  and free for commercial, academic, and private use.
-+
-+Here's an example, to give you an impression:
-+
-+.. literalinclude:: ../examples/demo.py
-+
-+(You can find this example as
-+:download:`examples/demo.py <../examples/demo.py>` in the PyOpenCL
-+source distribution.)
-+
-+Tutorials
-+=========
-+
-+* Gaston Hillar's `two-part article series
-+  <http://www.drdobbs.com/open-source/easy-opencl-with-python/240162614>`_
-+  in Dr. Dobb's Journal provides a friendly introduction to PyOpenCL.
-+* `Simon McIntosh-Smith <http://www.cs.bris.ac.uk/~simonm/>`_
-+  and `Tom Deakin <http://www.tomdeakin.com/>`_'s course
-+  `Hands-on OpenCL <http://handsonopencl.github.io/>`_ contains
-+  both `lecture slides <https://github.com/HandsOnOpenCL/Lecture-Slides/releases>`_
-+  and `excercises (with solutions) <https://github.com/HandsOnOpenCL/Exercises-Solutions>`_
-+  (The course covers PyOpenCL as well as OpenCL's C and C++ APIs.)
-+* PyOpenCL course at `PASI <http://bu.edu/pasi>`_: Parts
-+  `1 <https://www.youtube.com/watch?v=X9mflbX1NL8>`_
-+  `2 <https://www.youtube.com/watch?v=MqvfCE_bKOg>`_
-+  `3 <https://www.youtube.com/watch?v=TAvKmV7CuUw>`_
-+  `4 <https://www.youtube.com/watch?v=SsuJ0LvZW1Q>`_
-+  (YouTube, 2011)
-+* PyOpenCL course at `DTU GPULab <http://gpulab.imm.dtu.dk/>`_ and
-+  `Simula <http://simula.no/>`_ (2011):
-+  `Lecture 1 <http://tiker.net/pub/simula-pyopencl-lec1.pdf>`_
-+  `Lecture 2 <http://tiker.net/pub/simula-pyopencl-lec2.pdf>`_
-+  `Problem set 1 <http://tiker.net/pub/simula-pyopencl-probset1.pdf>`_
-+  `Problem set 2 <http://tiker.net/pub/simula-pyopencl-probset2.pdf>`_
-+* Ian Johnson's `PyOpenCL tutorial <http://enja.org/2011/02/22/adventures-in-pyopencl-part-1-getting-started-with-python/>`_.
-+
-+Software that works with or enhances PyOpenCL
-+=============================================
-+
-+* Bogdan Opanchuk's `reikna <http://pypi.python.org/pypi/reikna>`_ offers a
-+  variety of GPU-based algorithms (FFT, random number generation, matrix
-+  multiplication) designed to work with :class:`pyopencl.array.Array` objects.
-+
-+* Gregor Thalhammer's `gpyfft <https://github.com/geggo/gpyfft>`_ provides a
-+  Python wrapper for the OpenCL FFT library clFFT from AMD.
-+
-+If you know of a piece of software you feel that should be on this list, please
-+let me know, or, even better, send a patch!
-+
-+Contents
-+========
-+
-+.. toctree::
-+    :maxdepth: 2
-+
-+    runtime
-+    array
-+    algorithm
-+    howto
-+    tools
-+    misc
-+
-+Note that this guide does not explain OpenCL programming and technology. Please
-+refer to the official `Khronos OpenCL documentation <http://khronos.org/opencl>`_
-+for that.
-+
-+PyOpenCL also has its own `web site <http://mathema.tician.de/software/pyopencl>`_,
-+where you can find updates, new versions, documentation, and support.
-+
-+Indices and tables
-+==================
-+
-+* :ref:`genindex`
-+* :ref:`modindex`
-+* :ref:`search`
-diff -Nur pyopencl-2015.1/doc/misc.rst pyopencl/doc/misc.rst
---- pyopencl-2015.1/doc/misc.rst	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/misc.rst	2015-03-05 20:44:55.749853109 +0100
-@@ -0,0 +1,510 @@
-+Installation
-+============
-+
-+Installation information is maintained collaboratively on the
-+`PyOpenCL Wiki <http://wiki.tiker.net/PyOpenCL/Installation>`_.
-+
-+Acknowledgments
-+===============
-+
-+Too many to list. Please see the
-+`commit log <https://github.com/pyopencl/pyopencl/commits/master>`_
-+for detailed acknowledgments.
-+
-+Tips
-+====
-+
-+Syntax highlighting
-+-------------------
-+
-+You can obtain Vim syntax highlighting for OpenCL C inlined in Python by
-+checking `this file
-+<https://github.com/pyopencl/pyopencl/blob/master/contrib/pyopencl.vim>`_.
-+
-+Note that the triple-quoted strings containing the source must start with
-+`"""//CL// ..."""`.
-+
-+IPython integration
-+-------------------
-+
-+PyOpenCL comes with IPython integration, which lets you seamlessly integrate
-+PyOpenCL kernels into your IPython notebooks. Simply load the PyOpenCL 
-+IPython extension using::
-+
-+    %load_ext pyopencl.ipython_ext
-+
-+and then use the ``%%cl_kernel`` 'cell-magic' command. See `this notebook
-+<http://nbviewer.ipython.org/urls/raw.githubusercontent.com/pyopencl/pyopencl/master/examples/ipython-demo.ipynb>`_
-+(which ships with PyOpenCL) for a demonstration.
-+
-+You can pass build options to be used for building the program executable by using the ``-o`` flag on the first line of the cell (next to the ``%%cl_kernel`` directive). For example: `%%cl_kernel -o "-cl-fast-relaxed-math"``.
-+
-+There are also line magics: ``cl_load_edit_kernel`` which will load a file into the next cell (adding ``cl_kernel`` to the first line) and ``cl_kernel_from_file`` which will compile kernels from a file (as if you copy-and-pasted the contents of the file to a cell with ``cl_kernel``). Boths of these magics take options ``-f`` to specify the file and optionally ``-o`` for build options.
-+
-+.. versionadded:: 2014.1
-+
-+Guidelines
-+==========
-+
-+.. _api-compatibility:
-+
-+API Stability
-+-------------
-+
-+I consider PyOpenCL's API "stable".  That doesn't mean it can't
-+change. But if it does, your code will generally continue to run. It
-+may however start spewing warnings about things you need to change to
-+stay compatible with future versions.
-+
-+Deprecation warnings will be around for a whole year, as identified by the
-+first number in the release name.  (the "2014" in "2014.1") I.e. a function
-+that was deprecated in 2014.n will generally be removed in 2015.n (or perhaps
-+later). Further, the stability promise applies for any code that's part of a
-+released version. It doesn't apply to undocumented bits of the API, and it
-+doesn't apply to unreleased code downloaded from git.
-+
-+.. _versus-c:
-+
-+Relation with OpenCL's C Bindings
-+---------------------------------
-+
-+We've tried to follow these guidelines when binding the OpenCL's
-+C interface to Python:
-+
-+* Remove the `cl_`, `CL_` and `cl` prefix from data types, macros and
-+  function names.
-+* Follow :pep:`8`, i.e.
-+
-+  * Make function names lowercase.
-+  * If a data type or function name is composed of more than one word,
-+    separate the words with a single underscore.
-+
-+* `get_info` functions become attributes.
-+* Object creation is done by constructors, to the extent possible.
-+  (i.e. minimize use of "factory functions")
-+
-+* If an operation involves two or more "complex" objects (like e.g. a
-+  kernel enqueue involves a kernel and a queue), refuse the temptation
-+  to guess which one should get a method for the operation.
-+  Instead, simply leave that command to be a function.
-+
-+.. _interoperability:
-+
-+Interoperability with other OpenCL software
-+-------------------------------------------
-+
-+Just about every object in :mod:`pyopencl` supports the following
-+interface (here shown as an example for :class:`pyopencl.MemoryObject`,
-+from which :class:`pyopencl.Buffer` and :class:`pyopencl.Image` inherit):
-+
-+* :meth:`pyopencl.MemoryObject.from_int_ptr`
-+* :attr:`pyopencl.MemoryObject.int_ptr`
-+
-+This allows retrieving the C-level pointer to an OpenCL object as a Python
-+integer, which may then be passed to other C libraries whose interfaces expose
-+OpenCL objects. It also allows turning C-level OpenCL objects obtained from
-+other software to be turned into the corresponding :mod:`pyopencl` objects.
-+
-+.. versionadded:: 2013.2
-+
-+User-visible Changes
-+====================
-+
-+Version 2014.1
-+--------------
-+.. note::
-+
-+    This version is currently under development. You can get snapshots from
-+    PyOpenCL's `git repository <https://github.com/pyopencl/pyopencl>`_
-+
-+* :ref:`ipython-integration`
-+* Bug fixes
-+
-+Version 2013.2
-+--------------
-+
-+* Add :meth:`pyopencl.array.Array.map_to_host`.
-+* Support *strides* on :func:`pyopencl.enqueue_map_buffer` and
-+  :func:`pyopencl.enqueue_map_image`.
-+* :class:`pyopencl.ImageFormat` was made comparable and hashable.
-+* :mod:`pyopencl.reduction` supports slicing (contributed by Alex Nitz)
-+* Added :ref:`interoperability`
-+* Bug fixes
-+
-+Version 2013.1
-+--------------
-+
-+* Vastly improved :ref:`custom-scan`.
-+* Add :func:`pyopencl.tools.match_dtype_to_c_struct`,
-+  for better integration of the CL and :mod:`numpy` type systems.
-+* More/improved Bessel functions.
-+  See `the source <https://github.com/pyopencl/pyopencl/tree/master/src/cl>`_.
-+* Add :envvar:`PYOPENCL_NO_CACHE` environment variable to aid debugging.
-+  (e.g. with AMD's CPU implementation, see
-+  `their programming guide <http://developer.amd.com/sdks/AMDAPPSDK/assets/AMD_Accelerated_Parallel_Processing_OpenCL_Programming_Guide.pdf>`_)
-+* Deprecated :func:`pyopencl.tools.register_dtype` in favor of
-+  :func:`pyopencl.tools.get_or_register_dtype`.
-+* Clean up the :class:`pyopencl.array.Array` constructor interface.
-+* Deprecate :class:`pyopencl.array.DefaultAllocator`.
-+* Deprecate :class:`pyopencl.tools.CLAllocator`.
-+* Introduce :class:`pyopencl.tools.DeferredAllocator`, :class:`pyopencl.tools.ImmediateAllocator`.
-+* Allow arrays whose beginning does not coincide with the beginning of their
-+  :attr:`pyopencl.array.Array.data` :class:`pyopencl.Buffer`.
-+  See :attr:`pyopencl.array.Array.base_data` and :attr:`pyopencl.array.Array.offset`.
-+  Note that not all functions in PyOpenCL support such arrays just yet. These
-+  will fail with :exc:`pyopencl.array.ArrayHasOffsetError`.
-+* Add :meth:`pyopencl.array.Array.__getitem__` and :meth:`pyopencl.array.Array.__setitem__`,
-+  supporting generic slicing.
-+
-+  It is *possible* to create non-contiguous arrays using this functionality.
-+  Most operations (elementwise etc.) will not work on such arrays.
-+
-+  Note also that some operations (specifically, reductions and scans) on sliced
-+  arrays that start past the beginning of the original array will fail for now.
-+  This will be fixed in a future release.
-+
-+* :class:`pyopencl.CommandQueue` may be used as a context manager (in a ``with`` statement)
-+* Add :func:`pyopencl.clmath.atan2`, :func:`pyopencl.clmath.atan2pi`.
-+* Add :func:`pyopencl.array.concatenate`.
-+* Add :meth:`pyopencl.Kernel.capture_call`.
-+
-+.. note::
-+
-+    The addition of :meth:`pyopencl.array.Array.__getitem__` has an unintended
-+    consequence due to `numpy bug 3375
-+    <https://github.com/numpy/numpy/issues/3375>`_.  For instance, this
-+    expression::
-+
-+        numpy.float32(5) * some_pyopencl_array
-+
-+    may take a very long time to execute. This is because :mod:`numpy` first
-+    builds an object array of (compute-device) scalars (!) before it decides that
-+    that's probably not such a bright idea and finally calls
-+    :meth:`pyopencl.array.Array.__rmul__`.
-+
-+    Note that only left arithmetic operations of :class:`pyopencl.array.Array`
-+    by :mod:`numpy` scalars are affected. Python's number types (:class:`float` etc.)
-+    are unaffected, as are right multiplications.
-+
-+    If a program that used to run fast suddenly runs extremely slowly, it is
-+    likely that this bug is to blame.
-+
-+    Here's what you can do:
-+
-+    * Use Python scalars instead of :mod:`numpy` scalars.
-+    * Switch to right multiplications if possible.
-+    * Use a patched :mod:`numpy`. See the bug report linked above for a pull
-+      request with a fix.
-+    * Switch to a fixed version of :mod:`numpy` when available.
-+
-+Version 2012.1
-+--------------
-+
-+* Support for complex numbers.
-+* Support for Bessel functions. (experimental)
-+* Numerous fixes.
-+
-+Version 2011.2
-+--------------
-+
-+* Add :func:`pyopencl.enqueue_migrate_mem_object`.
-+* Add :func:`pyopencl.image_from_array`.
-+* IMPORTANT BUGFIX: Kernel caching was broken for all the 2011.1.x releases, with
-+  severe consequences on the execution time of :class:`pyopencl.array.Array`
-+  operations.
-+  Henrik Andresen at a `PyOpenCL workshop at DTU <http://gpulab.imm.dtu.dk/courses.html>`_
-+  first noticed the strange timings.
-+* All comparable PyOpenCL objects are now also hashable.
-+* Add :func:`pyopencl.tools.context_dependent_memoize` to the documented
-+  functionality.
-+* Base :mod:`pyopencl.clrandom` on `RANLUXCL <https://bitbucket.org/ivarun/ranluxcl>`_,
-+  add functionality.
-+* Add :class:`pyopencl.NannyEvent` objects.
-+* Add :mod:`pyopencl.characterize`.
-+* Ensure compatibility with OS X Lion.
-+* Add :func:`pyopencl.tools.register_dtype` to enable scan/reduction on struct types.
-+* :func:`pyopencl.enqueue_migrate_mem_object` was renamed
-+  :func:`pyopencl.enqueue_migrate_mem_object_ext`.
-+  :func:`pyopencl.enqueue_migrate_mem_object` now refers to the OpenCL 1.2 function
-+  of this name, if available.
-+* :func:`pyopencl.create_sub_devices` was renamed
-+  :func:`pyopencl.create_sub_devices_ext`.
-+  :func:`pyopencl.create_sub_devices` now refers to the OpenCL 1.2 function
-+  of this name, if available.
-+* Alpha support for OpenCL 1.2.
-+
-+Version 2011.1.2
-+----------------
-+
-+* More bug fixes.
-+
-+Version 2011.1.1
-+----------------
-+
-+* Fixes for Python 3 compatibility. (with work by Christoph Gohlke)
-+
-+Version 2011.1
-+--------------
-+
-+* All *is_blocking* parameters now default to *True* to avoid
-+  crashy-by-default behavior. (suggested by Jan Meinke)
-+  In particular, this change affects
-+  :func:`pyopencl.enqueue_read_buffer`,
-+  :func:`pyopencl.enqueue_write_buffer`,
-+  :func:`pyopencl.enqueue_read_buffer_rect`,
-+  :func:`pyopencl.enqueue_write_buffer_rect`,
-+  :func:`pyopencl.enqueue_read_image`,
-+  :func:`pyopencl.enqueue_write_image`,
-+  :func:`pyopencl.enqueue_map_buffer`,
-+  :func:`pyopencl.enqueue_map_image`.
-+* Add :mod:`pyopencl.reduction`.
-+* Add :ref:`reductions`.
-+* Add :mod:`pyopencl.scan`.
-+* Add :meth:`pyopencl.MemoryObject.get_host_array`.
-+* Deprecate context arguments of
-+  :func:`pyopencl.array.to_device`,
-+  :func:`pyopencl.array.zeros`,
-+  :func:`pyopencl.array.arange`.
-+* Make construction of :class:`pyopencl.array.Array` more flexible (*cqa* argument.)
-+* Add :ref:`memory-pools`.
-+* Add vector types, see :class:`pyopencl.array.vec`.
-+* Add :attr:`pyopencl.array.Array.strides`, :attr:`pyopencl.array.Array.flags`.
-+  Allow the creation of arrys in C and Fortran order.
-+* Add :func:`pyopencl.enqueue_copy`. Deprecate all other transfer functions.
-+* Add support for numerous extensions, among them device fission.
-+* Add a compiler cache.
-+* Add the 'g_times_l' keyword arg to kernel execution.
-+
-+Version 0.92
-+------------
-+
-+* Add support for OpenCL 1.1.
-+* Add support for the
-+  `cl_khr_gl_sharing <ghttp://www.khronos.org/registry/cl/extensions/khr/cl_khr_gl_sharing.txt>`_
-+  extension, leading to working GL interoperability.
-+* Add :meth:`pyopencl.Kernel.set_args`.
-+* The call signature of :meth:`pyopencl.Kernel.__call__` changed to
-+  emphasize the importance of *local_size*.
-+* Add :meth:`pyopencl.Kernel.set_scalar_arg_dtypes`.
-+* Add support for the
-+  `cl_nv_device_attribute_query <http://www.khronos.org/registry/cl/extensions/khr/cl_nv_device_attribute_query.txt>`_
-+  extension.
-+* Add :meth:`pyopencl.array.Array` and related functionality.
-+* Make build not depend on Boost C++.
-+
-+Version 0.91.5
-+--------------
-+
-+* Add :attr:`pyopencl.ImageFormat.channel_count`,
-+  :attr:`pyopencl.ImageFormat.dtype_size`,
-+  :attr:`pyopencl.ImageFormat.itemsize`.
-+* Add missing :func:`pyopencl.enqueue_copy_buffer`.
-+* Add :func:`pyopencl.create_some_context`.
-+* Add :func:`pyopencl.enqueue_barrier`, which was previously missing.
-+
-+Version 0.91.4
-+--------------
-+
-+A bugfix release. No user-visible changes.
-+
-+Version 0.91.3
-+--------------
-+
-+* All parameters named *host_buffer* were renamed *hostbuf* for consistency
-+  with the :class:`pyopencl.Buffer` constructor introduced in 0.91.
-+  Compatibility code is in place.
-+* The :class:`pyopencl.Image` constructor does not need a *shape* parameter if the
-+  given *hostbuf* has *hostbuf.shape*.
-+* The :class:`pyopencl.Context` constructor can now be called without parameters.
-+
-+Version 0.91.2
-+--------------
-+
-+* :meth:`pyopencl.Program.build` now captures build logs and adds them
-+  to the exception text.
-+* Deprecate :func:`pyopencl.create_context_from_type` in favor of second
-+  form of :class:`pyopencl.Context` constructor
-+* Introduce :class:`pyopencl.LocalMemory`.
-+* Document kernel invocation and :meth:`pyopencl.Kernel.set_arg`.
-+
-+Version 0.91.1
-+--------------
-+
-+* Fixed a number of bugs, notably involving :class:`pyopencl.Sampler`.
-+* :class:`pyopencl.Device`, :class:`pyopencl.Platform`,
-+  :class:`pyopencl.Context` now have nicer string representations.
-+* Add :attr:`Image.shape`. (suggested by David Garcia)
-+
-+Version 0.91
-+------------
-+
-+* Add :ref:`gl-interop`.
-+* Add a test suite.
-+* Fix numerous `get_info` bugs. (reports by David Garcia and the test suite)
-+* Add :meth:`pyopencl.ImageFormat.__repr__`.
-+* Add :meth:`pyopencl.addressing_mode.to_string` and colleagues.
-+* The `pitch` arguments to
-+  :func:`pyopencl.create_image_2d`,
-+  :func:`pyopencl.create_image_3d`,
-+  :func:`pyopencl.enqueue_read_image`, and
-+  :func:`pyopencl.enqueue_write_image`
-+  are now defaulted to zero. The argument order of `enqueue_{read,write}_image`
-+  has changed for this reason.
-+* Deprecate
-+  :func:`pyopencl.create_image_2d`,
-+  :func:`pyopencl.create_image_3d`
-+  in favor of the :class:`pyopencl.Image` constructor.
-+* Deprecate
-+  :func:`pyopencl.create_program_with_source`,
-+  :func:`pyopencl.create_program_with_binary`
-+  in favor of the :class:`pyopencl.Program` constructor.
-+* Deprecate
-+  :func:`pyopencl.create_buffer`,
-+  :func:`pyopencl.create_host_buffer`
-+  in favor of the :class:`pyopencl.Buffer` constructor.
-+* :meth:`pyopencl.MemoryObject.get_image_info` now actually exists.
-+* Add :attr:`pyopencl.MemoryObject.image.info`.
-+* Fix API tracing.
-+* Add constructor arguments to :class:`pyopencl.ImageFormat`.  (suggested by David Garcia)
-+
-+Version 0.90.4
-+--------------
-+
-+* Add build fixes for Windows and OS X.
-+
-+Version 0.90.3
-+--------------
-+
-+* Fix a GNU-ism in the C++ code of the wrapper.
-+
-+Version 0.90.2
-+--------------
-+
-+* Fix :meth:`pyopencl.Platform.get_info`.
-+* Fix passing properties to :class:`pyopencl.CommandQueue`.
-+  Also fix related documentation.
-+
-+Version 0.90.1
-+--------------
-+
-+* Fix building on the Mac.
-+
-+Version 0.90
-+------------
-+
-+* Initial release.
-+
-+.. _license:
-+
-+License
-+=======
-+
-+PyOpenCL is licensed to you under the MIT/X Consortium license:
-+
-+Copyright (c) 2009-13 Andreas Klöckner and Contributors.
-+
-+Permission is hereby granted, free of charge, to any person
-+obtaining a copy of this software and associated documentation
-+files (the "Software"), to deal in the Software without
-+restriction, including without limitation the rights to use,
-+copy, modify, merge, publish, distribute, sublicense, and/or sell
-+copies of the Software, and to permit persons to whom the
-+Software is furnished to do so, subject to the following
-+conditions:
-+
-+The above copyright notice and this permission notice shall be
-+included in all copies or substantial portions of the Software.
-+
-+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-+OTHER DEALINGS IN THE SOFTWARE.
-+
-+PyOpenCL includes derivatives of parts of the `Thrust
-+<https://code.google.com/p/thrust/>`_ computing package (in particular the scan
-+implementation). These parts are licensed as follows:
-+
-+    Copyright 2008-2011 NVIDIA Corporation
-+
-+    Licensed under the Apache License, Version 2.0 (the "License");
-+    you may not use this file except in compliance with the License.
-+    You may obtain a copy of the License at
-+
-+        <http://www.apache.org/licenses/LICENSE-2.0>
-+
-+    Unless required by applicable law or agreed to in writing, software
-+    distributed under the License is distributed on an "AS IS" BASIS,
-+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-+    See the License for the specific language governing permissions and
-+    limitations under the License.
-+
-+.. note::
-+
-+    If you use Apache-licensed parts, be aware that these may be incompatible
-+    with software licensed exclusively under GPL2.  (Most software is licensed
-+    as GPL2 or later, in which case this is not an issue.)
-+
-+PyOpenCL includes the RANLUXCL random number generator:
-+
-+    Copyright (c) 2011 Ivar Ursin Nikolaisen
-+
-+    Permission is hereby granted, free of charge, to any person obtaining a copy of this
-+    software and associated documentation files (the "Software"), to deal in the Software
-+    without restriction, including without limitation the rights to use, copy, modify,
-+    merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
-+    permit persons to whom the Software is furnished to do so, subject to the following
-+    conditions:
-+
-+    The above copyright notice and this permission notice shall be included in all copies
-+    or substantial portions of the Software.
-+
-+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-+    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-+    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-+    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
-+    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
-+    OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-+
-+Frequently Asked Questions
-+==========================
-+
-+The FAQ is maintained collaboratively on the
-+`Wiki FAQ page <http://wiki.tiker.net/PyOpenCL/FrequentlyAskedQuestions>`_.
-+
-+Citing PyOpenCL
-+===============
-+
-+We are not asking you to gratuitously cite PyOpenCL in work that is otherwise
-+unrelated to software. That said, if you do discuss some of the development
-+aspects of your code and would like to highlight a few of the ideas behind
-+PyOpenCL, feel free to cite `this article
-+<http://dx.doi.org/10.1016/j.parco.2011.09.001>`_:
-+
-+    Andreas Klöckner, Nicolas Pinto, Yunsup Lee, Bryan Catanzaro, Paul Ivanov,
-+    Ahmed Fasih, PyCUDA and PyOpenCL: A scripting-based approach to GPU
-+    run-time code generation, Parallel Computing, Volume 38, Issue 3, March
-+    2012, Pages 157-174.
-+
-+Here's a Bibtex entry for your convenience::
-+
-+    @article{kloeckner_pycuda_2012,
-+       author = {{Kl{\"o}ckner}, Andreas
-+            and {Pinto}, Nicolas
-+            and {Lee}, Yunsup
-+            and {Catanzaro}, B.
-+            and {Ivanov}, Paul
-+            and {Fasih}, Ahmed },
-+       title = "{PyCUDA and PyOpenCL: A Scripting-Based Approach to GPU Run-Time Code Generation}",
-+       journal = "Parallel Computing",
-+       volume = "38",
-+       number = "3",
-+       pages = "157--174",
-+       year = "2012",
-+       issn = "0167-8191",
-+       doi = "10.1016/j.parco.2011.09.001",
-+    }
-+
-diff -Nur pyopencl-2015.1/doc/runtime.rst pyopencl/doc/runtime.rst
---- pyopencl-2015.1/doc/runtime.rst	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/runtime.rst	2015-03-05 20:44:55.749853109 +0100
-@@ -0,0 +1,975 @@
-+.. _reference-doc:
-+
-+.. include:: subst.rst
-+
-+OpenCL Runtime
-+==============
-+
-+Version Queries
-+---------------
-+
-+.. module:: pyopencl
-+.. moduleauthor:: Andreas Kloeckner <inform at tiker.net>
-+
-+.. data:: VERSION
-+
-+    Gives the numeric version of PyOpenCL as a variable-length tuple
-+    of integers. Enables easy version checks such as
-+    *VERSION >= (0, 93)*.
-+
-+.. data:: VERSION_STATUS
-+
-+    A text string such as `"rc4"` or `"beta"` qualifying the status
-+    of the release.
-+
-+.. data:: VERSION_TEXT
-+
-+    The full release name (such as `"0.93rc4"`) in string form.
-+
-+.. function:: get_cl_header_version()
-+
-+    Return a variable-length tuple of integers representing the
-+    version of the OpenCL header against which PyOpenCL was
-+    compiled.
-+
-+    .. versionadded:: 0.92
-+
-+.. _errors:
-+
-+Error Reporting
-+---------------
-+
-+.. class:: Error
-+
-+    Base class for all PyOpenCL exceptions.
-+
-+.. class:: MemoryError
-+
-+.. class:: LogicError
-+
-+.. class:: RuntimeError
-+
-+Constants
-+---------
-+
-+.. include:: constants.inc
-+
-+Platforms, Devices and Contexts
-+-------------------------------
-+
-+.. function:: get_platforms()
-+
-+    Return a list of :class:`Platform` instances.
-+
-+.. class:: Platform
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`platform_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. method:: get_info(param)
-+
-+        See :class:`platform_info` for values of *param*.
-+
-+    .. method:: get_devices(device_type=device_type.ALL)
-+
-+        Return a list of devices matching *device_type*.
-+        See :class:`device_type` for values of *device_type*.
-+
-+        .. versionchanged:: 2013.2
-+
-+            This used to raise an exception if no matching
-+            devices were found. Now, it will simply return
-+            an empty list.
-+
-+    .. automethod:: from_int_ptr
-+    .. autoattribute:: int_ptr
-+
-+    |comparable|
-+
-+.. class:: Device
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`device_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. method:: get_info(param)
-+
-+        See :class:`device_info` for values of *param*.
-+
-+    .. automethod:: from_int_ptr
-+    .. autoattribute:: int_ptr
-+
-+    Two instances of this class may be compared using *=="* and *"!="*.
-+
-+.. class:: Context(devices=None, properties=None, dev_type=None)
-+
-+    Create a new context. *properties* is a list of key-value
-+    tuples, where each key must be one of :class:`context_properties`.
-+    At most one of *devices* and *dev_type* may be not `None`, where
-+    *devices* is a list of :class:`Device` instances, and
-+    *dev_type* is one of the :class:`device_type` constants.
-+    If neither is specified, a context with a *dev_type* of
-+    :attr:`device_type.DEFAULT` is created.
-+
-+    .. note::
-+
-+        Calling the constructor with no arguments will fail for recent
-+        CL drivers that support the OpenCL ICD. If you want similar,
-+        just-give-me-a-context-already behavior, we recommend
-+        :func:`create_some_context`. See, e.g. this
-+        `explanation by AMD <http://developer.amd.com/support/KnowledgeBase/Lists/KnowledgeBase/DispForm.aspx?ID=71>`_.
-+
-+    .. note::
-+
-+        For
-+        :attr:`context_properties.CL_GL_CONTEXT_KHR`,
-+        :attr:`context_properties.CL_EGL_DISPLAY_KHR`,
-+        :attr:`context_properties.CL_GLX_DISPLAY_KHR`,
-+        :attr:`context_properties.CL_WGL_HDC_KHR`, and
-+        :attr:`context_properties.CL_CGL_SHAREGROUP_KHR`
-+        :attr:`context_properties.CL_CGL_SHAREGROUP_APPLE`
-+        the value in the key-value pair is a PyOpenGL context or display
-+        instance.
-+
-+    .. versionchanged:: 0.91.2
-+        Constructor arguments *dev_type* added.
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`context_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. method:: get_info(param)
-+
-+        See :class:`context_info` for values of *param*.
-+
-+    .. method:: create_sub_devices(properties)
-+
-+        *properties* is an array of one (or more) of the forms::
-+
-+            [ dpp.EQUALLY, 8]
-+            [ dpp.BY_COUNTS, 5, 7, 9, dpp.PARTITION_BY_COUNTS_LIST_END]
-+            [ dpp.BY_NAMES, 5, 7, 9, dpp.PARTITION_BY_NAMES_LIST_END]
-+            [ dpp.BY_AFFINITY_DOMAIN, dad.L1_CACHE]
-+
-+        where `dpp` represents :class:`device_partition_property`
-+        and `dad` represent :class:`device_affinity_domain`.
-+
-+        `PROPERTIES_LIST_END_EXT` is added automatically.
-+
-+        Only available with CL 1.2.
-+
-+        .. versionadded:: 2011.2
-+
-+    .. method:: create_sub_devices_ext(properties)
-+
-+        *properties* is an array of one (or more) of the forms::
-+
-+            [ dppe.EQUALLY, 8]
-+            [ dppe.BY_COUNTS, 5, 7, 9, dppe.PARTITION_BY_COUNTS_LIST_END]
-+            [ dppe.BY_NAMES, 5, 7, 9, dppe.PARTITION_BY_NAMES_LIST_END]
-+            [ dppe.BY_AFFINITY_DOMAIN, ad.L1_CACHE]
-+
-+        where `dppe` represents :class:`device_partition_property_ext`
-+        and `ad` represent :class:`affinity_domain_ext`.
-+
-+        `PROPERTIES_LIST_END_EXT` is added automatically.
-+
-+        Only available with the `cl_ext_device_fission` extension.
-+
-+        .. versionadded:: 2011.1
-+
-+    .. automethod:: from_int_ptr
-+    .. autoattribute:: int_ptr
-+
-+    |comparable|
-+
-+.. function:: create_some_context(interactive=True)
-+
-+    Create a :class:`Context` 'somehow'.
-+
-+    If multiple choices for platform and/or device exist, *interactive*
-+    is True, and *sys.stdin.isatty()* is also True,
-+    then the user is queried about which device should be chosen.
-+    Otherwise, a device is chosen in an implementation-defined manner.
-+
-+Command Queues and Events
-+-------------------------
-+
-+.. class:: CommandQueue(context, device=None, properties=None)
-+
-+    Create a new command queue. *properties* is a bit field
-+    consisting of :class:`command_queue_properties` values.
-+
-+    if *device* is None, one of the devices in *context* is chosen
-+    in an implementation-defined manner.
-+
-+    A :class:`CommandQueue` may be used as a context manager, like this::
-+
-+        with cl.CommandQueue(self.cl_context) as queue:
-+            enqueue_stuff(queue, ...)
-+
-+    :meth:`finish` is automatically called at the end of the context.
-+
-+    .. versionadded:: 2013.1
-+
-+        Context manager capability.
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`command_queue_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. method:: get_info(param)
-+
-+        See :class:`command_queue_info` for values of *param*.
-+
-+    .. method:: set_property(prop, enable)
-+
-+        See :class:`command_queue_properties` for possible values of *prop*.
-+        *enable* is a :class:`bool`.
-+
-+        Unavailable in OpenCL 1.1 and newer.
-+
-+    .. method:: flush()
-+    .. method:: finish()
-+
-+    .. automethod:: from_int_ptr
-+    .. autoattribute:: int_ptr
-+
-+    |comparable|
-+
-+.. class:: Event
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`event_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. attribute:: profile.info
-+
-+        Lower case versions of the :class:`profiling_info` constants
-+        may be used as attributes on the attribute `profile` of this
-+        class to directly query profiling info.
-+
-+        For example, you may use *evt.profile.end* instead of
-+        *evt.get_profiling_info(pyopencl.profiling_info.END)*.
-+
-+    .. method:: get_info(param)
-+
-+        See :class:`event_info` for values of *param*.
-+
-+    .. method:: get_profiling_info(param)
-+
-+        See :class:`profiling_info` for values of *param*.
-+        See :attr:`profile` for an easier way of obtaining
-+        the same information.
-+
-+    .. method:: wait()
-+
-+    .. automethod:: from_int_ptr
-+    .. autoattribute:: int_ptr
-+
-+    |comparable|
-+
-+.. function:: wait_for_events(events)
-+
-+.. function:: enqueue_barrier(queue, wait_for=None)
-+
-+    Enqueues a barrier operation. which ensures that all queued commands in
-+    command_queue have finished execution. This command is a synchronization
-+    point.
-+
-+    .. versionadded:: 0.91.5
-+    .. versionchanged:: 2011.2
-+        Takes *wait_for* and returns an :class:`Event`
-+
-+.. function:: enqueue_marker(queue, wait_for=None)
-+
-+    Returns an :class:`Event`.
-+
-+    .. versionchanged:: 2011.2
-+        Takes *wait_for*.
-+
-+.. class:: UserEvent(context)
-+
-+    A subclass of :class:`Event`. Only available with OpenCL 1.1 and newer.
-+
-+    .. versionadded:: 0.92
-+
-+    .. method:: set_status(status)
-+
-+        See :class:`command_execution_status` for possible values of *status*.
-+
-+.. class:: NannyEvent
-+
-+    Transfers between host and device return events of this type. They hold
-+    a reference to the host-side buffer and wait for the transfer to complete
-+    when they are freed. Therefore, they can safely release the reference to
-+    the object they're guarding upon destruction.
-+
-+    A subclass of :class:`Event`.
-+
-+    .. versionadded:: 2011.2
-+
-+    .. method:: get_ward()
-+
-+    .. method:: wait()
-+
-+        In addition to performing the same wait as :meth:`Event.wait()`, this
-+        method also releases the reference to the guarded object.
-+
-+Memory
-+------
-+
-+.. class:: MemoryObject
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`mem_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. attribute:: hostbuf
-+
-+    .. method:: get_info(param)
-+
-+        See :class:`mem_info` for values of *param*.
-+
-+    .. method:: release()
-+
-+    .. method:: get_host_array(shape, dtype, order="C")
-+
-+        Return the memory object's associated host memory
-+        area as a :class:`numpy.ndarray` of the given *shape*,
-+        *dtype* and *order*.
-+
-+    .. automethod:: from_int_ptr
-+    .. autoattribute:: int_ptr
-+
-+    |comparable|
-+
-+.. function:: enqueue_migrate_mem_objects(queue, mem_objects, flags=0, wait_for=None)
-+
-+    :param flags: from :class:`mem_migration_flags`
-+
-+    .. versionadded:: 2011.2
-+
-+    Only available with CL 1.2.
-+
-+.. function:: enqueue_migrate_mem_object_ext(queue, mem_objects, flags=0, wait_for=None)
-+
-+    :param flags: from :class:`migrate_mem_object_flags_ext`
-+
-+    .. versionadded:: 2011.2
-+
-+    Only available with the `cl_ext_migrate_memobject`
-+    extension.
-+
-+Buffers
-+^^^^^^^
-+
-+.. class:: Buffer(context, flags, size=0, hostbuf=None)
-+
-+    Create a :class:`Buffer`.
-+    See :class:`mem_flags` for values of *flags*.
-+    If *hostbuf* is specified, *size* defaults to the size of
-+    the specified buffer if it is passed as zero.
-+
-+    :class:`Buffer` inherits from :class:`MemoryObject`.
-+
-+    .. note::
-+
-+        Python also defines a type of `buffer object
-+        <https://docs.python.org/3.4/c-api/buffer.html>`_,
-+        and PyOpenCL interacts with those, too, as the host-side
-+        target of :func:`enqueue_copy`. Make sure to always be
-+        clear on whether a :class:`Buffer` or a Python buffer
-+        object is needed.
-+
-+    Note that actual memory allocation in OpenCL may be deferred.
-+    Buffers are attached to a :class:`Context` and are only
-+    moved to a device once the buffer is used on that device.
-+    That is also the point when out-of-memory errors will occur.
-+    If you'd like to be sure that there's enough memory for
-+    your allocation, either use :func:`enqueue_migrate_mem_objects`
-+    (if available) or simply perform a small transfer to the
-+    buffer. See also :class:`pyopencl.tools.ImmediateAllocator`.
-+
-+    .. method:: get_sub_region(origin, size, flags=0)
-+
-+        Only available in OpenCL 1.1 and newer.
-+
-+    .. method:: __getitem__(slc)
-+
-+        *slc* is a :class:`slice` object indicating from which byte index range
-+        a sub-buffer is to be created. The *flags* argument of
-+        :meth:`get_sub_region` is set to the same flags with which *self* was
-+        created.
-+
-+
-+.. function:: enqueue_fill_buffer(queue, mem, pattern, offset, size, wait_for=None)
-+
-+    :arg pattern: a buffer object (likely a :class:`numpy.ndarray`)
-+
-+    |std-enqueue-blurb|
-+
-+    Only available with CL 1.2.
-+
-+    .. versionadded:: 2011.2
-+
-+Image Formats
-+^^^^^^^^^^^^^
-+
-+.. class:: ImageFormat([channel_order, channel_type])
-+
-+
-+    .. attribute:: channel_order
-+
-+        See :class:`channel_order` for possible values.
-+
-+    .. attribute:: channel_data_type
-+
-+        See :class:`channel_type` for possible values.
-+
-+    .. attribute:: channel_count
-+
-+        .. versionadded:: 0.91.5
-+
-+    .. attribute:: dtype_size
-+
-+        .. versionadded:: 0.91.5
-+
-+    .. attribute:: itemsize
-+
-+        .. versionadded:: 0.91.5
-+
-+    .. method:: __repr__
-+
-+        Returns a :class:`str` representation of the image format.
-+
-+        .. versionadded:: 0.91
-+
-+    |comparable|
-+
-+    .. versionchanged:: 0.91
-+
-+        Constructor arguments added.
-+
-+    .. versionchanged:: 2013.2
-+
-+        :class:`ImageFormat` was made comparable and hashable
-+
-+.. function:: get_supported_image_formats(context, flags, image_type)
-+
-+    See :class:`mem_flags` for possible values of *flags*
-+    and :class:`mem_object_type` for possible values of *image_type*.
-+
-+Images
-+^^^^^^
-+.. class:: Image(context, flags, format, shape=None, pitches=None, hostbuf=None, is_array=False, buffer=None):
-+
-+    See :class:`mem_flags` for values of *flags*.
-+    *shape* is a 2- or 3-tuple. *format* is an instance of :class:`ImageFormat`.
-+    *pitches* is a 1-tuple for 2D images and a 2-tuple for 3D images, indicating
-+    the distance in bytes from one scan line to the next, and from one 2D image
-+    slice to the next.
-+
-+    If *hostbuf* is given and *shape* is `None`, then *hostbuf.shape* is
-+    used as the *shape* parameter.
-+
-+    :class:`Image` inherits from :class:`MemoryObject`.
-+
-+    .. note::
-+
-+        If you want to load images from :mod:`numpy.ndarray` instances or read images
-+        back into them, be aware that OpenCL images expect the *x* dimension to vary
-+        fastest, whereas in the default (C) order of :mod:`numpy` arrays, the last index
-+        varies fastest. If your array is arranged in the wrong order in memory,
-+        there are two possible fixes for this:
-+
-+        * Convert the array to Fortran (column-major) order using :func:`numpy.asarray`.
-+
-+        * Pass *ary.T.copy()* to the image creation function.
-+
-+    .. versionadded:: 0.91
-+
-+    .. versionchanged:: 2011.2
-+        Added *is_array* and *buffer*, which are only available on CL 1.2 and newer.
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`mem_info`
-+        and :class:`image_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. attribute:: shape
-+
-+        Return the value of the *shape* constructor argument as a :class:`tuple`.
-+
-+    .. method:: get_image_info(param)
-+
-+        See :class:`image_info` for values of *param*.
-+
-+    .. method:: release()
-+
-+    |comparable|
-+
-+.. function:: image_from_array(ctx, ary, num_channels=None, mode="r", norm_int=False)
-+
-+    Build a 2D or 3D :class:`Image` from the :class:`numpy.ndarray` *ary*.  If
-+    *num_channels* is greater than one, the last dimension of *ary* must be
-+    identical to *num_channels*. *ary* must be in C order. If *num_channels* is
-+    not given, it defaults to 1 for scalar types and the number of entries
-+    for :ref:`vector-types`.
-+
-+    The :class:`ImageFormat` is chosen as the first *num_channels* components
-+    of "RGBA".
-+
-+    :param mode: "r" or "w" for read/write
-+
-+    .. note::
-+
-+        When reading from the image object, the indices passed to `read_imagef` are
-+        in the reverse order from what they would be when accessing *ary* from
-+        Python.
-+
-+    If *norm_int* is `True`, then the integer values are normalized to a floating
-+    point scale of 0..1 when read.
-+
-+    .. versionadded:: 2011.2
-+
-+.. function:: enqueue_fill_image(queue, mem, color, origin, region, wait_for=None)
-+
-+    :arg color: a buffer object (likely a :class:`numpy.ndarray`)
-+
-+    |std-enqueue-blurb|
-+
-+    Only available with CL 1.2.
-+
-+    .. versionadded:: 2011.2
-+
-+Transfers
-+^^^^^^^^^
-+
-+.. autofunction:: enqueue_copy(queue, dest, src, **kwargs)
-+
-+Mapping Memory into Host Address Space
-+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-+
-+.. class:: MemoryMap
-+
-+    .. method:: release(queue=None, wait_for=None)
-+
-+.. function:: enqueue_map_buffer(queue, buf, flags, offset, shape, dtype, order="C", strides=None, wait_for=None, is_blocking=True)
-+
-+    |explain-waitfor|
-+    *shape*, *dtype*, and *order* have the same meaning
-+    as in :func:`numpy.empty`.
-+    See :class:`map_flags` for possible values of *flags*.
-+    *strides*, if given, overrides *order*.
-+
-+    :return: a tuple *(array, event)*. *array* is a
-+        :class:`numpy.ndarray` representing the host side
-+        of the map. Its *.base* member contains a
-+        :class:`MemoryMap`.
-+
-+    .. versionchanged:: 2011.1
-+        *is_blocking* now defaults to True.
-+
-+    .. versionchanged:: 2013.1
-+        *order* now defaults to "C".
-+
-+    .. versionchanged:: 2013.2
-+        Added *strides* argument.
-+
-+.. function:: enqueue_map_image(queue, buf, flags, origin, region, shape, dtype, order="C", strides=None, wait_for=None, is_blocking=True)
-+
-+    |explain-waitfor|
-+    *shape*, *dtype*, and *order* have the same meaning
-+    as in :func:`numpy.empty`.
-+    See :class:`map_flags` for possible values of *flags*.
-+    *strides*, if given, overrides *order*.
-+
-+    :return: a tuple *(array, event)*. *array* is a
-+        :class:`numpy.ndarray` representing the host side
-+        of the map. Its *.base* member contains a
-+        :class:`MemoryMap`.
-+
-+    .. versionchanged:: 2011.1
-+        *is_blocking* now defaults to True.
-+
-+    .. versionchanged:: 2013.1
-+        *order* now defaults to "C".
-+
-+    .. versionchanged:: 2013.2
-+        Added *strides* argument.
-+
-+Samplers
-+^^^^^^^^
-+
-+.. class:: Sampler(context, normalized_coords, addressing_mode, filter_mode)
-+
-+    *normalized_coords* is a :class:`bool` indicating whether
-+    to use coordinates between 0 and 1 (*True*) or the texture's
-+    natural pixel size (*False*).
-+    See :class:`addressing_mode` and :class:`filter_mode` for possible
-+    argument values.
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`sampler_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. method:: get_info(param)
-+
-+        See :class:`sampler_info` for values of *param*.
-+
-+    .. automethod:: from_int_ptr
-+    .. autoattribute:: int_ptr
-+
-+    |comparable|
-+
-+Programs and Kernels
-+--------------------
-+
-+.. class:: Program(context, src)
-+           Program(context, devices, binaries)
-+
-+    *binaries* must contain one binary for each entry in *devices*.
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`program_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. method:: get_info(param)
-+
-+        See :class:`program_info` for values of *param*.
-+
-+    .. method:: get_build_info(device, param)
-+
-+        See :class:`program_build_info` for values of *param*.
-+
-+    .. method:: build(options=[], devices=None)
-+
-+        *options* is a string of compiler flags.
-+        Returns *self*.
-+
-+        By default, built binaries are cached in an on-disk cache called
-+        :file:`pyopencl-compiler-cache-vN-uidNAME-pyVERSION` in the directory
-+        returned by :func:`tempfile.gettempdir`.  By setting the environment
-+        variable :envvar:`PYOPENCL_NO_CACHE` to any non-empty value, this
-+        caching is suppressed.  Any options found in the environment variable
-+        :envvar:`PYOPENCL_BUILD_OPTIONS` will be appended to *options*.
-+
-+        .. versionchanged:: 2011.1
-+            *options* may now also be a :class:`list` of :class:`str`.
-+
-+        .. versionchanged:: 2013.1
-+            Added :envvar:`PYOPENCL_NO_CACHE`.
-+            Added :envvar:`PYOPENCL_BUILD_OPTIONS`.
-+
-+    .. method:: compile(self, options=[], devices=None, headers=[])
-+
-+        :param headers: a list of tuples *(name, program)*.
-+
-+        Only available with CL 1.2.
-+
-+        .. versionadded:: 2011.2
-+
-+    .. attribute:: kernel_name
-+
-+        :class:`Kernel` objects can be produced from a built
-+        (see :meth:`build`) program simply by attribute lookup.
-+
-+        .. note::
-+
-+            The :class:`program_info` attributes live
-+            in the same name space and take precedence over
-+            :class:`Kernel` names.
-+
-+    .. method:: all_kernels()
-+
-+        Returns a list of all :class:`Kernel` objects in the :class:`Program`.
-+
-+    .. automethod:: from_int_ptr
-+    .. autoattribute:: int_ptr
-+
-+    |comparable|
-+
-+.. function:: create_program_with_built_in_kernels(context, devices, kernel_names)
-+
-+    Only available with CL 1.2.
-+
-+    .. versionadded:: 2011.2
-+
-+.. function:: link_program(context, programs, options=[], devices=None)
-+
-+    Only available with CL 1.2.
-+
-+    .. versionadded:: 2011.2
-+
-+.. function:: unload_platform_compiler(platform)
-+
-+    Only available with CL 1.2.
-+
-+    .. versionadded:: 2011.2
-+
-+.. class:: Kernel(program, name)
-+
-+    .. attribute:: info
-+
-+        Lower case versions of the :class:`kernel_info` constants
-+        may be used as attributes on instances of this class
-+        to directly query info attributes.
-+
-+    .. method:: get_info(param)
-+
-+        See :class:`kernel_info` for values of *param*.
-+
-+    .. method:: get_work_group_info(param, device)
-+
-+        See :class:`kernel_work_group_info` for values of *param*.
-+
-+    .. method:: get_arg_info(arg_index, param)
-+
-+        See :class:`kernel_arg_info` for values of *param*.
-+
-+        Only available in OpenCL 1.2 and newer.
-+
-+    .. method:: set_arg(self, index, arg)
-+
-+        *arg* may be
-+
-+        * `None`: This may be passed for `__global` memory references
-+          to pass a NULL pointer to the kernel.
-+        * Anything that satisfies the Python buffer interface,
-+          in particular :class:`numpy.ndarray`, :class:`str`,
-+          or :mod:`numpy`'s sized scalars, such as :class:`numpy.int32`
-+          or :class:`numpy.float64`.
-+
-+          .. note::
-+
-+              Note that Python's own :class:`int` or :class:`float`
-+              objects will not work out of the box. See
-+              :meth:`Kernel.set_scalar_arg_dtypes` for a way to make
-+              them work. Alternatively, the standard library module
-+              :mod:`struct` can be used to convert Python's native
-+              number types to binary data in a :class:`str`.
-+
-+        * An instance of :class:`MemoryObject`. (e.g. :class:`Buffer`,
-+          :class:`Image`, etc.)
-+        * An instance of :class:`LocalMemory`.
-+        * An instance of :class:`Sampler`.
-+
-+    .. method:: set_args(self, *args)
-+
-+        Invoke :meth:`set_arg` on each element of *args* in turn.
-+
-+        .. versionadded:: 0.92
-+
-+    .. method:: set_scalar_arg_dtypes(arg_dtypes)
-+
-+        Inform the wrapper about the sized types of scalar
-+        :class:`Kernel` arguments. For each argument,
-+        *arg_dtypes* contains an entry. For non-scalars,
-+        this must be *None*. For scalars, it must be an
-+        object acceptable to the :class:`numpy.dtype`
-+        constructor, indicating that the corresponding
-+        scalar argument is of that type.
-+
-+        After invoking this function with the proper information,
-+        most suitable number types will automatically be
-+        cast to the right type for kernel invocation.
-+
-+        .. note ::
-+
-+            The information set by this rountine is attached to a single kernel
-+            instance. A new kernel instance is created every time you use
-+            `program.kernel` attribute access. The following will therefore not
-+            work::
-+
-+               prg = cl.Program(...).build()
-+               prg.kernel.set_scalar_arg_dtypes(...)
-+               prg.kernel(queue, n_globals, None, args)
-+
-+
-+    .. method:: __call__(queue, global_size, local_size, *args, global_offset=None, wait_for=None, g_times_l=False)
-+
-+        Use :func:`enqueue_nd_range_kernel` to enqueue a kernel execution, after using
-+        :meth:`set_args` to set each argument in turn. See the documentation for
-+        :meth:`set_arg` to see what argument types are allowed.
-+        |std-enqueue-blurb|
-+
-+        *None* may be passed for local_size.
-+
-+        If *g_times_l* is specified, the global size will be multiplied by the
-+        local size. (which makes the behavior more like Nvidia CUDA) In this case,
-+        *global_size* and *local_size* also do not have to have the same number
-+        of dimensions.
-+
-+        .. note::
-+
-+            :meth:`__call__` is *not* thread-safe. It sets the arguments using :meth:`set_args`
-+            and then runs :func:`enqueue_nd_range_kernel`. Another thread could race it
-+            in doing the same things, with undefined outcome. This issue is inherited
-+            from the C-level OpenCL API. The recommended solution is to make a kernel
-+            (i.e. access `prg.kernel_name`, which corresponds to making a new kernel)
-+            for every thread that may enqueue calls to the kernel.
-+
-+            A solution involving implicit locks was discussed and decided against on the
-+            mailing list in `October 2012
-+            <http://lists.tiker.net/pipermail/pyopencl/2012-October/001311.html>`_.
-+
-+        .. versionchanged:: 0.92
-+            *local_size* was promoted to third positional argument from being a
-+            keyword argument. The old keyword argument usage will continue to
-+            be accepted with a warning throughout the 0.92 release cycle.
-+            This is a backward-compatible change (just barely!) because
-+            *local_size* as third positional argument can only be a
-+            :class:`tuple` or *None*.  :class:`tuple` instances are never valid
-+            :class:`Kernel` arguments, and *None* is valid as an argument, but
-+            its treatment in the wrapper had a bug (now fixed) that prevented
-+            it from working.
-+
-+        .. versionchanged:: 2011.1
-+            Added the *g_times_l* keyword arg.
-+
-+    .. method:: capture_call(filename, queue, global_size, local_size, *args, global_offset=None, wait_for=None, g_times_l=False)
-+
-+        This method supports the exact same interface as :meth:`__call__`, but
-+        instead of invoking the kernel, it writes a self-contained PyOpenCL program
-+        to *filename* that reproduces this invocation. Data and kernel source code
-+        will be packaged up in *filename*'s source code.
-+
-+        This is mainly intended as a debugging aid. For example, it can be used
-+        to automate the task of creating a small, self-contained test case for
-+        an observed problem. It can also help separate a misbehaving kernel from
-+        a potentially large or time-consuming outer code.
-+
-+        To use, simply change::
-+
-+            evt = my_kernel(queue, gsize, lsize, arg1, arg2, ...)
-+
-+        to::
-+
-+            evt = my_kernel.capture_call("bug.py", queue, gsize, lsize, arg1, arg2, ...)
-+
-+        .. versionadded:: 2013.1
-+
-+    .. automethod:: from_int_ptr
-+    .. autoattribute:: int_ptr
-+
-+    |comparable|
-+
-+.. class:: LocalMemory(size)
-+
-+    A helper class to pass `__local` memory arguments to kernels.
-+
-+    .. versionadded:: 0.91.2
-+
-+    .. attribute:: size
-+
-+        The size of local buffer in bytes to be provided.
-+
-+.. function:: enqueue_nd_range_kernel(queue, kernel, global_work_size, local_work_size, global_work_offset=None, wait_for=None, g_times_l=False)
-+
-+    |std-enqueue-blurb|
-+
-+    If *g_times_l* is specified, the global size will be multiplied by the
-+    local size. (which makes the behavior more like Nvidia CUDA) In this case,
-+    *global_size* and *local_size* also do not have to have the same number
-+    of dimensions.
-+
-+    .. versionchanged:: 2011.1
-+        Added the *g_times_l* keyword arg.
-+
-+
-+.. function:: enqueue_task(queue, kernel, wait_for=None)
-+
-+    |std-enqueue-blurb|
-+
-+.. _gl-interop:
-+
-+GL Interoperability
-+-------------------
-+
-+Functionality in this section is only available when PyOpenCL is compiled
-+with GL support. See :func:`have_gl`.
-+
-+.. versionadded:: 0.91
-+
-+.. function:: have_gl()
-+
-+    Return *True* if PyOpenCL was compiled with OpenGL interoperability, otherwise *False*.
-+
-+.. function:: get_gl_sharing_context_properties()
-+
-+    Return a :class:`list` of :class:`context_properties` that will
-+    allow a newly created context to share the currently active GL
-+    context.
-+
-+.. function:: get_apple_cgl_share_group()
-+
-+    Get share group handle for current CGL context.
-+
-+    Apple OS X only.
-+
-+    .. versionadded:: 2011.1
-+
-+.. class:: GLBuffer(context, flags, bufobj)
-+
-+    :class:`GLBuffer` inherits from :class:`MemoryObject`.
-+
-+    .. attribute:: gl_object
-+
-+.. class:: GLRenderBuffer(context, flags, bufobj)
-+
-+    :class:`GLRenderBuffer` inherits from :class:`MemoryObject`.
-+
-+    .. attribute:: gl_object
-+
-+.. class:: GLTexture(context, flags, texture_target, miplevel, texture, dims)
-+
-+    *dims* is either 2 or 3.
-+    :class:`GLTexture` inherits from :class:`Image`.
-+
-+    .. attribute:: gl_object
-+
-+    .. method:: get_gl_texture_info(param)
-+
-+        See :class:`gl_texture_info` for values of *param*.  Only available when PyOpenCL is compiled with GL support. See :func:`have_gl`.
-+
-+.. function:: enqueue_acquire_gl_objects(queue, mem_objects, wait_for=None)
-+
-+    *mem_objects* is a list of :class:`MemoryObject` instances.
-+    |std-enqueue-blurb|
-+
-+.. function:: enqueue_release_gl_objects(queue, mem_objects, wait_for=None)
-+
-+    *mem_objects* is a list of :class:`MemoryObject` instances. |std-enqueue-blurb|
-+
-+.. function:: get_gl_context_info_khr(properties, param_name, platform=None)
-+
-+    Get information on which CL device corresponds to a given
-+    GL/EGL/WGL/CGL device.
-+
-+    See the :class:`Context` constructor for the meaning of
-+    *properties* and :class:`gl_context_info` for *param_name*.
-+
-+
-+    .. versionchanged:: 2011.2
-+        Accepts the *platform* argument.  Using *platform* equal to None is
-+        deprecated as of PyOpenCL 2011.2.
-diff -Nur pyopencl-2015.1/doc/_static/akdoc.css pyopencl/doc/_static/akdoc.css
---- pyopencl-2015.1/doc/_static/akdoc.css	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/_static/akdoc.css	2015-03-05 20:44:55.746519776 +0100
-@@ -0,0 +1,59 @@
-+pre {
-+  line-height: 110%;
-+}
-+
-+.footer {
-+  background-color: #eee;
-+}
-+
-+body > div.container {
-+  margin-top:10px;
-+}
-+
-+dd {
-+  margin-left: 40px;
-+}
-+
-+tt.descname {
-+  font-size: 100%;
-+}
-+
-+code {
-+  color: rgb(51,51,51);
-+}
-+
-+h1 {
-+  padding-bottom:7px;
-+  border-bottom: 1px solid #ccc;
-+}
-+
-+h2 {
-+  padding-bottom:5px;
-+  border-bottom: 1px solid #ccc;
-+}
-+
-+h3 {
-+  padding-bottom:5px;
-+  border-bottom: 1px solid #ccc;
-+}
-+
-+.rubric {
-+  font-size: 120%;
-+  padding-bottom:1px;
-+  border-bottom: 1px solid #ccc;
-+}
-+
-+.headerlink {
-+  padding-left: 1ex;
-+  padding-right: 1ex;
-+}
-+
-+a.headerlink:hover {
-+  text-decoration: none;
-+}
-+
-+blockquote p {
-+  font-size: 100%;
-+  font-weight: normal;
-+  line-height: normal;
-+};
-diff -Nur pyopencl-2015.1/doc/subst.rst pyopencl/doc/subst.rst
---- pyopencl-2015.1/doc/subst.rst	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/subst.rst	2015-03-05 20:44:55.749853109 +0100
-@@ -0,0 +1,13 @@
-+.. |comparable| replace:: Instances of this class are hashable, and two
-+    instances of this class may be compared using *"=="* and *"!="*.
-+    (Hashability was added in version 2011.2.)
-+
-+.. |buf-iface| replace:: must implement the Python buffer interface.
-+    (e.g. by being an :class:`numpy.ndarray`)
-+.. |explain-waitfor| replace:: *wait_for*
-+    may either be *None* or a list of :class:`pyopencl.Event` instances for
-+    whose completion this command waits before starting exeuction.
-+.. |std-enqueue-blurb| replace:: Returns a new :class:`pyopencl.Event`. |explain-waitfor|
-+
-+.. |copy-depr| replace:: **Note:** This function is deprecated as of PyOpenCL 2011.1.
-+        Use :func:`enqueue_copy` instead.
-diff -Nur pyopencl-2015.1/doc/_templates/layout.html pyopencl/doc/_templates/layout.html
---- pyopencl-2015.1/doc/_templates/layout.html	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/_templates/layout.html	2015-03-05 20:44:55.746519776 +0100
-@@ -0,0 +1,2 @@
-+{% extends "!layout.html" %}
-+{% set bootswatch_css_custom = ['_static/akdoc.css']%}
-diff -Nur pyopencl-2015.1/doc/tools.rst pyopencl/doc/tools.rst
---- pyopencl-2015.1/doc/tools.rst	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/tools.rst	2015-03-05 20:44:55.749853109 +0100
-@@ -0,0 +1,140 @@
-+Built-in Utilities
-+==================
-+
-+.. module:: pyopencl.tools
-+
-+.. _memory-pools:
-+
-+Memory Pools
-+------------
-+
-+The constructor :func:`pyopencl.Buffer` can consume a fairly large amount of
-+processing time if it is invoked very frequently. For example, code based on
-+:class:`pyopencl.array.Array` can easily run into this issue because a
-+fresh memory area is allocated for each intermediate result. Memory pools are a
-+remedy for this problem based on the observation that often many of the block
-+allocations are of the same sizes as previously used ones.
-+
-+Then, instead of fully returning the memory to the system and incurring the 
-+associated reallocation overhead, the pool holds on to the memory and uses it
-+to satisfy future allocations of similarly-sized blocks. The pool reacts
-+appropriately to out-of-memory conditions as long as all memory allocations
-+are made through it. Allocations performed from outside of the pool may run
-+into spurious out-of-memory conditions due to the pool owning much or all of
-+the available memory.
-+
-+Using :class:`pyopencl.array.Array` instances with a :class:`MemoryPool` is
-+not complicated::
-+
-+    mem_pool = cl_tools.MemoryPool(cl_tools.ImmediateAllocator(queue))
-+    a_dev = cl_array.arange(queue, 2000, dtype=np.float32, allocator=mem_pool)
-+
-+.. class:: PooledBuffer
-+
-+    An object representing a :class:`MemoryPool`-based allocation of
-+    device memory.  Once this object is deleted, its associated device
-+    memory is returned to the pool. This supports the same interface
-+    as :class:`pyopencl.Buffer`.
-+
-+.. class:: DeferredAllocator(context, mem_flags=pyopencl.mem_flags.READ_WRITE)
-+
-+    *mem_flags* takes its values from :class:`pyopencl.mem_flags` and corresponds
-+    to the *flags* argument of :class:`pyopencl.Buffer`. DeferredAllocator
-+    has the same semantics as regular OpenCL buffer allocation, i.e. it may
-+    promise memory to be available that may (in any call to a buffer-using
-+    CL function) turn out to not exist later on. (Allocations in CL are
-+    bound to contexts, not devices, and memory availability depends on which
-+    device the buffer is used with.)
-+
-+    .. versionchanged::
-+        In version 2013.1, :class:`CLAllocator` was deprecated and replaced
-+        by :class:`DeferredAllocator`.
-+
-+    .. method:: __call__(size)
-+
-+        Allocate a :class:`pyopencl.Buffer` of the given *size*.
-+
-+.. class:: ImmediateAllocator(queue, mem_flags=pyopencl.mem_flags.READ_WRITE)
-+
-+    *mem_flags* takes its values from :class:`pyopencl.mem_flags` and corresponds
-+    to the *flags* argument of :class:`pyopencl.Buffer`. DeferredAllocator
-+    has the same semantics as regular OpenCL buffer allocation, i.e. it may
-+    promise memory to be available that later on (in any call to a buffer-using
-+    CL function).
-+
-+    .. versionadded:: 2013.1
-+
-+    .. method:: __call__(size)
-+
-+        Allocate a :class:`pyopencl.Buffer` of the given *size*.
-+
-+.. class:: MemoryPool(allocator)
-+
-+    A memory pool for OpenCL device memory. *allocator* must be an instance of
-+    one of the above classes, and should be an :class:`ImmediateAllocator`.
-+    The memory pool assumes that allocation failures are reported
-+    by the allocator immediately, and not in the OpenCL-typical
-+    deferred manner.
-+
-+    .. attribute:: held_blocks
-+
-+        The number of unused blocks being held by this pool.
-+
-+    .. attribute:: active_blocks
-+
-+        The number of blocks in active use that have been allocated
-+        through this pool.
-+
-+    .. method:: allocate(size)
-+
-+        Return a :class:`PooledBuffer` of the given *size*.
-+
-+    .. method:: __call__(size)
-+
-+        Synoynm for :meth:`allocate` to match :class:`CLAllocator` interface.
-+
-+        .. versionadded: 2011.2
-+
-+    .. method:: free_held
-+
-+        Free all unused memory that the pool is currently holding.
-+
-+    .. method:: stop_holding
-+
-+        Instruct the memory to start immediately freeing memory returned
-+        to it, instead of holding it for future allocations.
-+        Implicitly calls :meth:`free_held`.
-+        This is useful as a cleanup action when a memory pool falls out
-+        of use.
-+
-+CL-Object-dependent Caching
-+---------------------------
-+
-+.. autofunction:: first_arg_dependent_memoize
-+.. autofunction:: clear_first_arg_caches
-+
-+Testing
-+-------
-+
-+.. function:: pytest_generate_tests_for_pyopencl(metafunc)
-+
-+    Using the line::
-+
-+        from pyopencl.tools import pytest_generate_tests_for_pyopencl \
-+                as pytest_generate_tests
-+
-+    in your `pytest <http://pytest.org>`_ test scripts allows you to use the
-+    arguments *ctx_factory*, *device*, or *platform* in your test functions,
-+    and they will automatically be run for each OpenCL device/platform in the
-+    system, as appropriate.
-+
-+    The following two environment variables are also supported to control
-+    device/platform choice::
-+
-+        PYOPENCL_TEST=0:0,1;intel=i5,i7
-+
-+Device Characterization
-+-----------------------
-+
-+.. automodule:: pyopencl.characterize
-+    :members:
-diff -Nur pyopencl-2015.1/doc/upload-docs.sh pyopencl/doc/upload-docs.sh
---- pyopencl-2015.1/doc/upload-docs.sh	1970-01-01 01:00:00.000000000 +0100
-+++ pyopencl/doc/upload-docs.sh	2015-03-05 20:44:55.749853109 +0100
-@@ -0,0 +1,3 @@
-+#! /bin/sh
-+
-+rsync --progress --verbose --archive --delete _build/html/* doc-upload:doc/pyopencl
================================================================

---- gitweb:

http://git.pld-linux.org/gitweb.cgi/packages/python-pyopencl.git/commitdiff/dc8f5b2d501949b66a27327472137b9e0c5d0999




More information about the pld-cvs-commit mailing list