pyopencl 2024.2.2__cp312-cp312-win_amd64.whl → 2024.2.5__cp312-cp312-win_amd64.whl

pyopencl-2024.2.2.data/data/doc/runtime_queue.rst

@@ -1,182 +0,0 @@
-.. include:: subst.rst
-
-OpenCL Runtime: Command Queues and Events
-=========================================
-
-.. currentmodule:: pyopencl
-
-Command Queue
--------------
-
-.. 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.
-
-    *properties* may be a bitwise combination of values from
-    :class:`queue_properties` (or *None* which is equivalent to
-    passing *0*). This is compatible with both OpenCL 1.x and 2.x.
-
-    For OpenCL 2.0 and above, *properties* may also be a sequence
-    of keys and values from :class:`queue_properties` as accepted
-    by :c:func:`clCreateCommandQueueWithProperties` (see the OpenCL
-    spec for details). The trailing *0* is added automatically
-    and does not need to be included.
-
-    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 ``with``-delimited
-    context, and further operations on the queue are considered an error.
-
-    .. versionadded:: 2013.1
-
-        Context manager capability.
-
-    .. versionchanged:: 2018.2
-
-        Added the sequence-of-properties interface for OpenCL 2.
-
-    .. versionchanged:: 2022.1.4
-
-        Use of a command queue after its context manager completes
-        is now considered an error. :mod:`pyopencl` will warn about this
-        for a transitionary period and will start raising an exception
-        in 2023.
-
-    .. 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|
-
-Event
------
-
-.. 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
-
-        An instance of :class:`ProfilingInfoGetter`.
-
-    .. 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
-
-    .. method:: set_callback(type, cb)
-
-        Add the callback *cb* with signature ``cb(status)`` to the callback
-        queue for the event status *type* (one of the values of
-        :class:`command_execution_status`, except :attr:`command_execution_status.QUEUED`).
-
-        See the OpenCL specification for restrictions on what *cb* may and may not do.
-
-        .. versionadded:: 2015.2
-
-    |comparable|
-
-.. class:: ProfilingInfoGetter
-
-   .. attribute:: 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)*.
-
-Event Subclasses
-----------------
-
-.. 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.
-
-Synchronization Functions
--------------------------
-
-.. 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*.
-

pyopencl-2024.2.2.data/data/doc/subst.rst

@@ -1,36 +0,0 @@
-.. |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.) Two objects are considered
-    the same if the underlying OpenCL object is the same, as established
-    by C pointer equality.
-
-.. |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:`~pyopencl.enqueue_copy` instead.
-
-.. |glsize| replace:: *global_size* and *local_size* are tuples of identical length, with
-        between one and three entries. *global_size* specifies the overall size
-        of the computational grid: one work item will be launched for every
-        integer point in the grid. *local_size* specifies the workgroup size,
-        which must evenly divide the *global_size* in a dimension-by-dimension
-        manner.  *None* may be passed for local_size, in which case the
-        implementation will use an implementation-defined workgroup size.
-        If *g_times_l* is *True*, 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 entries.
-
-.. |empty-nd-range| replace:: *allow_empty_ndrange* is a :class:`bool` indicating
-        how an empty NDRange is to be treated, where "empty" means that one or more
-        entries of *global_size* or *local_size* are zero. OpenCL itself does not
-        allow enqueueing kernels over empty NDRanges. Setting this flag to *True*
-        enqueues a marker with a wait list (``clEnqueueMarkerWithWaitList``)
-        to obtain the synchronization effects that would have resulted from
-        the kernel enqueue.
-        Setting *allow_empty_ndrange* to *True* requires OpenCL 1.2 or newer.

pyopencl-2024.2.2.data/data/doc/tools.rst

@@ -1,4 +0,0 @@
-Built-in Utilities
-==================
-
-.. automodule:: pyopencl.tools

pyopencl-2024.2.2.data/data/doc/types.rst

@@ -1,42 +0,0 @@
-OpenCL Type Mapping
-===================
-
-.. module:: pyopencl.cltypes
-
-.. _type-mappings:
-
-Scalar Types
-------------
-
-For ease of use, a the :mod:`pyopencl.cltypes` module provides convenient mapping
-from OpenCL type names to their equivalent :mod:`numpy` types. This saves you
-from referring back to the OpenCL spec to see that a ``cl_long`` is 64 bit
-unsigned integer. Use the module as follows:
-
-.. doctest::
-
-    >>> import numpy as np
-    >>> import pyopencl as cl
-    >>> import pyopencl.cltypes
-    >>> cl_uint = cl.cltypes.uint(42)   # maps to numpy.uint32
-    >>> cl_long = cl.cltypes.long(1235) # maps to numpy.int64
-    >>> floats = np.empty((128,), dtype=cl.cltypes.float) # array of numpy.float32
-
-.. note::
-
-    The OpenCL type ``bool`` does not have a corresponding :mod:`numpy` type
-    defined here, because OpenCL does not specify the in-memory representation
-    (or even the storage size) for this type.
-
-Vector Types
-------------
-
-The corresponding vector types are also made available in the same package,
-allowing you to easily create :mod:`numpy` arrays with the appropriate memory
-layout.
-
-.. doctest::
-
-    >>> import numpy as np
-    >>> array_of_float16 = np.empty((128,), dtype=cl.cltypes.float16) # array of float16
-