pyopencl 2024.1__cp39-cp39-macosx_11_0_arm64.whl → 2024.2.1__cp39-cp39-macosx_11_0_arm64.whl

pyopencl/clrandom.py

@@ -24,7 +24,7 @@ THE SOFTWARE.
 # {{{ documentation
 
 __doc__ = """
-PyOpenCL now includes and uses some of the `Random123 random number generators
+PyOpenCL includes and uses some of the `Random123 random number generators
 <https://www.deshawresearch.com/resources.html>`__ by D.E. Shaw
 Research. In addition to being usable through the convenience functions above,
 they are available in any piece of code compiled through PyOpenCL by::
@@ -38,15 +38,6 @@ and the `Threefry source
 <https://github.com/inducer/pyopencl/blob/main/pyopencl/cl/pyopencl-random123/threefry.cl>`__
 for some documentation if you're planning on using Random123 directly.
 
-.. note::
-
-    PyOpenCL previously had documented support for the RANLUXCL random number
-    generator (``https://bitbucket.org/ivarun/ranluxcl``) by Ivar Ursin
-    Nikolaisen. This support is now deprecated because of the general slowness
-    of these generators and will be removed from PyOpenCL in the 2018.x series.
-    All users are encouraged to switch to one of the Random123 generators,
-    :class:`PhiloxGenerator` or :class:`ThreefryGenerator`.
-
 .. autoclass:: PhiloxGenerator
 
 .. autoclass:: ThreefryGenerator
@@ -58,363 +49,13 @@ for some documentation if you're planning on using Random123 directly.
 
 # }}}
 
+import numpy as np
+from pytools import memoize_method
+
 import pyopencl as cl
 import pyopencl.array as cl_array
 import pyopencl.cltypes as cltypes
 from pyopencl.tools import first_arg_dependent_memoize
-from pytools import memoize_method
-
-import numpy as np
-
-
-# {{{ RanluxGenerator (deprecated)
-
-class RanluxGenerator:
-    """
-    .. warning::
-
-        This class is deprecated, to be removed in PyOpenCL 2018.x.
-
-    .. versionadded:: 2011.2
-
-    .. attribute:: state
-
-        A :class:`pyopencl.array.Array` containing the state of the generator.
-
-    .. attribute:: nskip
-
-        nskip is an integer which can (optionally) be defined in the kernel
-        code as RANLUXCL_NSKIP. If this is done the generator will be faster
-        for luxury setting 0 and 1, or when the p-value is manually set to a
-        multiple of 24.
-    """
-
-    def __init__(self, queue, num_work_items=None,
-            luxury=None, seed=None, no_warmup=False,
-            use_legacy_init=False, max_work_items=None):
-        """
-        :param queue: :class:`pyopencl.CommandQueue`, only used for initialization
-        :param luxury: the "luxury value" of the generator, and should be 0-4,
-            where 0 is fastest and 4 produces the best numbers. It can also be
-            >=24, in which case it directly sets the p-value of RANLUXCL.
-        :param num_work_items: is the number of generators to initialize,
-            usually corresponding to the number of work-items in the NDRange
-            RANLUXCL will be used with.  May be *None*, in which case a default
-            value is used.
-        :param max_work_items: should reflect the maximum number of work-items
-            that will be used on any parallel instance of RANLUXCL. So for
-            instance if we are launching 5120 work-items on GPU1 and 10240
-            work-items on GPU2, GPU1's RANLUXCLTab would be generated by
-            calling ranluxcl_intialization with numWorkitems = 5120 while
-            GPU2's RANLUXCLTab would use numWorkitems = 10240. However
-            maxWorkitems must be at least 10240 for both GPU1 and GPU2, and it
-            must be set to the same value for both. (may be *None*)
-
-        .. versionchanged:: 2013.1
-
-            Added default value for ``num_work_items``.
-        """
-
-        from warnings import warn
-        warn("Ranlux random number generation is deprecated and will go away "
-                "in 2022.", DeprecationWarning, stacklevel=2)
-
-        if luxury is None:
-            luxury = 4
-
-        if num_work_items is None:
-            if queue.device.type & cl.device_type.CPU:
-                num_work_items = 8 * queue.device.max_compute_units
-            else:
-                num_work_items = 64 * queue.device.max_compute_units
-
-        if seed is None:
-            from time import time
-            seed = int(time()*1e6) % 2 << 30
-
-        self.context = queue.context
-        self.luxury = luxury
-        self.num_work_items = num_work_items
-
-        from pyopencl.characterize import has_double_support
-        self.support_double = has_double_support(queue.device)
-
-        self.no_warmup = no_warmup
-        self.use_legacy_init = use_legacy_init
-        self.max_work_items = max_work_items
-
-        src = """
-            %(defines)s
-
-            #include <pyopencl-ranluxcl.cl>
-
-            kernel void init_ranlux(unsigned seeds,
-                global ranluxcl_state_t *ranluxcltab)
-            {
-              if (get_global_id(0) < %(num_work_items)d)
-                ranluxcl_initialization(seeds, ranluxcltab);
-            }
-            """ % {
-                    "defines": self.generate_settings_defines(),
-                    "num_work_items": num_work_items
-                }
-        prg = cl.Program(queue.context, src).build()
-
-        # {{{ compute work group size
-
-        wg_size = None
-
-        import sys
-        import platform
-        if ("darwin" in sys.platform
-                and "Apple" in queue.device.platform.vendor
-                and platform.mac_ver()[0].startswith("10.7")
-                and queue.device.type & cl.device_type.CPU):
-            wg_size = (1,)
-
-        self.wg_size = wg_size
-
-        # }}}
-
-        self.state = cl_array.empty(queue, (num_work_items, 112), dtype=np.uint8)
-        self.state.fill(17)
-
-        prg.init_ranlux(queue, (num_work_items,), self.wg_size, np.uint32(seed),
-                self.state.data)
-
-    def generate_settings_defines(self, include_double_pragma=True):
-        lines = []
-        if include_double_pragma and self.support_double:
-            lines.append("""
-                #if __OPENCL_C_VERSION__ < 120
-                #pragma OPENCL EXTENSION cl_khr_fp64: enable
-                #endif
-                """)
-
-        lines.append("#define RANLUXCL_LUX %d" % self.luxury)
-
-        if self.no_warmup:
-            lines.append("#define RANLUXCL_NO_WARMUP")
-
-        if self.support_double:
-            lines.append("#define RANLUXCL_SUPPORT_DOUBLE")
-
-        if self.use_legacy_init:
-            lines.append("#define RANLUXCL_USE_LEGACY_INITIALIZATION")
-
-            if self.max_work_items:
-                lines.append(
-                        "#define RANLUXCL_MAXWORKITEMS %d" % self.max_work_items)
-
-        return "\n".join(lines)
-
-    @memoize_method
-    def get_gen_kernel(self, dtype, distribution="uniform"):
-        size_multiplier = 1
-        arg_dtype = dtype
-
-        if dtype == np.float64:
-            bits = 64
-            c_type = "double"
-            rng_expr = "(shift + scale * gen)"
-        elif dtype == np.float32:
-            bits = 32
-            c_type = "float"
-            rng_expr = "(shift + scale * gen)"
-        elif dtype == cltypes.float2:
-            bits = 32
-            c_type = "float"
-            rng_expr = "(shift + scale * gen)"
-            size_multiplier = 2
-            arg_dtype = np.float32
-        elif dtype in [cltypes.float3, cltypes.float4]:
-            bits = 32
-            c_type = "float"
-            rng_expr = "(shift + scale * gen)"
-            size_multiplier = 4
-            arg_dtype = np.float32
-        elif dtype == np.int32:
-            assert distribution == "uniform"
-            bits = 32
-            c_type = "int"
-            rng_expr = ("(shift "
-                    "+ convert_int4((float) scale * gen) "
-                    "+ convert_int4(((float) scale / (1<<24)) * gen))")
-
-        elif dtype == np.int64:
-            assert distribution == "uniform"
-            if self.support_double:
-                bits = 64
-            else:
-                bits = 32
-            c_type = "long"
-            rng_expr = ("(shift "
-                    "+ convert_long4((float) scale * gen) "
-                    "+ convert_long4(((float) scale / (1l<<24)) * gen)"
-                    "+ convert_long4(((float) scale / (1l<<48)) * gen)"
-                    ")")
-
-        else:
-            raise TypeError("unsupported RNG data type '%s'" % dtype)
-
-        rl_flavor = "%d%s" % (bits, {
-                "uniform": "",
-                "normal": "norm"
-                }[distribution])
-
-        src = """//CL//
-            %(defines)s
-
-            #include <pyopencl-ranluxcl.cl>
-
-            typedef %(output_t)s output_t;
-            typedef %(output_t)s4 output_vec_t;
-            #define NUM_WORKITEMS %(num_work_items)d
-            #define RANLUX_FUNC ranluxcl%(rlflavor)s
-            #define GET_RANDOM_NUM(gen) %(rng_expr)s
-
-            kernel void generate(
-                global ranluxcl_state_t *ranluxcltab,
-                global output_t *output,
-                unsigned long out_size,
-                output_t scale,
-                output_t shift)
-            {
-
-              ranluxcl_state_t ranluxclstate;
-              ranluxcl_download_seed(&ranluxclstate, ranluxcltab);
-
-              // output bulk
-              unsigned long idx = get_global_id(0)*4;
-              while (idx + 4 < out_size)
-              {
-                  output_vec_t ran = GET_RANDOM_NUM(RANLUX_FUNC(&ranluxclstate));
-                  vstore4(ran, 0, &output[idx]);
-                  idx += 4*NUM_WORKITEMS;
-              }
-
-              // output tail
-              output_vec_t tail_ran = GET_RANDOM_NUM(RANLUX_FUNC(&ranluxclstate));
-              if (idx < out_size)
-                output[idx] = tail_ran.x;
-              if (idx+1 < out_size)
-                output[idx+1] = tail_ran.y;
-              if (idx+2 < out_size)
-                output[idx+2] = tail_ran.z;
-              if (idx+3 < out_size)
-                output[idx+3] = tail_ran.w;
-
-              ranluxcl_upload_seed(&ranluxclstate, ranluxcltab);
-            }
-            """ % {
-                "defines": self.generate_settings_defines(),
-                "rlflavor": rl_flavor,
-                "output_t": c_type,
-                "num_work_items": self.num_work_items,
-                "rng_expr": rng_expr
-                }
-
-        prg = cl.Program(self.context, src).build()
-        knl = prg.generate
-        knl.set_scalar_arg_dtypes([None, None, np.uint64, arg_dtype, arg_dtype])
-
-        return knl, size_multiplier
-
-    def fill_uniform(self, ary, a=0, b=1, queue=None):
-        """Fill *ary* with uniformly distributed random numbers in the interval
-        *(a, b)*, endpoints excluded.
-
-        :return: a :class:`pyopencl.Event`
-
-        .. versionchanged:: 2014.1.1
-
-            Added return value.
-        """
-
-        if queue is None:
-            queue = ary.queue
-
-        knl, size_multiplier = self.get_gen_kernel(ary.dtype, "uniform")
-        evt = knl(queue,
-                (self.num_work_items,), None,
-                self.state.data, ary.data, ary.size*size_multiplier,
-                b-a, a, wait_for=ary.events)
-        ary.add_event(evt)
-        self.state.add_event(evt)
-        return ary
-
-    def uniform(self, *args, **kwargs):
-        """Make a new empty array, apply :meth:`fill_uniform` to it.
-        """
-        a = kwargs.pop("a", 0)
-        b = kwargs.pop("b", 1)
-
-        result = cl_array.empty(*args, **kwargs)
-        self.fill_uniform(result, queue=result.queue, a=a, b=b)
-        return result
-
-    def fill_normal(self, ary, mu=0, sigma=1, queue=None):
-        """Fill *ary* with normally distributed numbers with mean *mu* and
-        standard deviation *sigma*.
-
-        .. versionchanged:: 2014.1.1
-
-            Added return value.
-        """
-
-        if queue is None:
-            queue = ary.queue
-
-        knl, size_multiplier = self.get_gen_kernel(ary.dtype, "normal")
-        evt = knl(queue,
-                (self.num_work_items,), self.wg_size,
-                self.state.data, ary.data, ary.size*size_multiplier, sigma, mu,
-                wait_for=ary.events)
-        ary.add_event(evt)
-        self.state.add_event(evt)
-        return evt
-
-    def normal(self, *args, **kwargs):
-        """Make a new empty array, apply :meth:`fill_normal` to it.
-        """
-        mu = kwargs.pop("mu", 0)
-        sigma = kwargs.pop("sigma", 1)
-
-        result = cl_array.empty(*args, **kwargs)
-        self.fill_normal(result, queue=result.queue, mu=mu, sigma=sigma)
-        return result
-
-    @memoize_method
-    def get_sync_kernel(self):
-        src = """//CL//
-            {defines}
-
-            #include <pyopencl-ranluxcl.cl>
-
-            kernel void sync(
-                global ranluxcl_state_t *ranluxcltab)
-            {{
-              ranluxcl_state_t ranluxclstate;
-              ranluxcl_download_seed(&ranluxclstate, ranluxcltab);
-              ranluxcl_synchronize(&ranluxclstate);
-              ranluxcl_upload_seed(&ranluxclstate, ranluxcltab);
-            }}
-            """.format(
-                defines=self.generate_settings_defines(),
-                )
-        prg = cl.Program(self.context, src).build()
-        return prg.sync
-
-    def synchronize(self, queue):
-        """The generator gets inefficient when different work items invoke the
-        generator a differing number of times. This function ensures
-        efficiency.
-        """
-
-        self.get_sync_kernel()(queue, (self.num_work_items,),
-                self.wg_size, self.state.data)
-
-# }}}
 
 
 # {{{ Random123 generators
@@ -738,14 +379,9 @@ def _get_generator(context):
     return gen
 
 
-def fill_rand(result, queue=None, luxury=None, a=0, b=1):
+def fill_rand(result, queue=None, a=0, b=1):
     """Fill *result* with random values in the range :math:`[0, 1)`.
     """
-    if luxury is not None:
-        from warnings import warn
-        warn("Specifying the 'luxury' argument is deprecated and will stop being "
-                "supported in PyOpenCL 2018.x", stacklevel=2)
-
     if queue is None:
         queue = result.queue
     gen = _get_generator(queue.context)

pyopencl/cltypes.py

@@ -18,9 +18,12 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 """
 
+import warnings
+
 import numpy as np
+
 from pyopencl.tools import get_or_register_dtype
-import warnings
+
 
 if __file__.endswith("array.py"):
     warnings.warn(

pyopencl/compyte/dtypes.py

@@ -111,8 +111,8 @@ class DTypeRegistry:
 # {{{ C types
 
 def fill_registry_with_c_types(reg, respect_windows, include_bool=True):
-    from sys import platform
     import struct
+    from sys import platform
 
     if include_bool:
         # bool is of unspecified size in the OpenCL spec and may in fact be

pyopencl/compyte/ndarray/gen_elemwise.py

@@ -7,9 +7,9 @@ that ndim is 0 as with all scalar type.
 
 
 import numpy
+import pygpu_ndarray as gpu_ndarray
 import StringIO
 
-import pygpu_ndarray as gpu_ndarray
 _CL_MODE = hasattr(gpu_ndarray, "set_opencl_context")
 
 
@@ -20,6 +20,7 @@ if _CL_MODE:
     from pyopencl.tools import dtype_to_ctype
 #    import pyopencl._mymako as mako
     from pyopencl._cluda import CLUDA_PREAMBLE
+
     # TODO: use mako to get rid of the %if
     CLUDA_PREAMBLE = CLUDA_PREAMBLE[:455]
     CLUDA_PREAMBLE += """
@@ -51,12 +52,12 @@ else:
 #define GDIM_2 gridDim.z
  """
 
-from theano import Apply
-from theano import scalar
-from theano.tensor import TensorType
+import logging
+
 import theano
+from theano import Apply, scalar
+from theano.tensor import TensorType
 
-import logging
 _logger_name = 'compyte.gen_elemwise'
 _logger = logging.getLogger(_logger_name)
 _logger.setLevel(logging.INFO)

pyopencl/compyte/ndarray/gen_reduction.py

@@ -1,7 +1,6 @@
 import numpy
 import StringIO
 
-
 _CL_MODE = False  # "pyopencl" in __name__
 
 
@@ -12,6 +11,7 @@ if _CL_MODE:
     from pyopencl.tools import dtype_to_ctype
 #    import pyopencl._mymako as mako
     from pyopencl._cluda import CLUDA_PREAMBLE
+
     # TODO: use mako to get rid of the %if
     CLUDA_PREAMBLE = CLUDA_PREAMBLE[:455]
     CLUDA_PREAMBLE += """
@@ -43,13 +43,13 @@ else:
 #define GDIM_2 gridDim.z
  """
 
-from theano import Apply
-from theano import scalar
-from theano.tensor import TensorType
-from theano.sandbox.cuda import CudaNdarrayType
+import logging
+
 import theano
+from theano import Apply, scalar
+from theano.sandbox.cuda import CudaNdarrayType
+from theano.tensor import TensorType
 
-import logging
 _logger_name = 'compyte.gen_reduction'
 _logger = logging.getLogger(_logger_name)
 _logger.setLevel(logging.INFO)

pyopencl/compyte/ndarray/setup_opencl.py

@@ -1,8 +1,8 @@
 import os
-
-from distutils.core import setup, Extension
 from distutils.command.build_ext import build_ext
+from distutils.core import Extension, setup
 from distutils.dep_util import newer
+
 import numpy as np
 
 
@@ -82,6 +82,7 @@ class build_ext_nvcc(build_ext):
             self.build_extension(ext)
 
 import sys
+
 if sys.platform == 'darwin':
     libcl_args = {'extra_link_args': ['-framework', 'OpenCL']}
 else:

pyopencl/compyte/ndarray/test_gpu_elemwise.py

@@ -1,12 +1,13 @@
 # TODO: test other dtype
+from functools import reduce
+
 import numpy
+import pygpu_ndarray as gpu_ndarray
 import theano
 
-import pygpu_ndarray as gpu_ndarray
 from .gen_elemwise import MyGpuNdArray, elemwise_collapses
-from .test_gpu_ndarray import (dtypes_all, enable_double,
-                              gen_gpu_nd_array, product)
-from functools import reduce
+from .test_gpu_ndarray import (dtypes_all, enable_double, gen_gpu_nd_array,
+                               product)
 
 
 def rand(shape, dtype):

pyopencl/compyte/ndarray/test_gpu_ndarray.py

@@ -1,7 +1,6 @@
 import copy
 
 import numpy
-
 import pygpu_ndarray as gpu_ndarray
 
 enable_double = True

pyopencl/elementwise.py

@@ -31,14 +31,12 @@ import enum
 from typing import Any, List, Optional, Tuple, Union
 
 import numpy as np
+from pytools import memoize_method
 
 import pyopencl as cl
-from pyopencl.tools import context_dependent_memoize
 from pyopencl.tools import (
-        dtype_to_ctype, DtypedArgument, VectorArg, ScalarArg,
-        KernelTemplateBase, dtype_to_c_struct)
-
-from pytools import memoize_method
+    DtypedArgument, KernelTemplateBase, ScalarArg, VectorArg,
+    context_dependent_memoize, dtype_to_c_struct, dtype_to_ctype)
 
 
 # {{{ elementwise kernel code generator
@@ -121,7 +119,7 @@ def get_elwise_kernel_and_types(
         use_range: bool = False,
         **kwargs: Any) -> Tuple[cl.Kernel, List[DtypedArgument]]:
 
-    from pyopencl.tools import parse_arg_list, get_arg_offset_adjuster_code
+    from pyopencl.tools import get_arg_offset_adjuster_code, parse_arg_list
     parsed_args = parse_arg_list(arguments, with_offset=True)
 
     auto_preamble = kwargs.pop("auto_preamble", True)

pyopencl/invoker.py

@@ -22,14 +22,16 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 """
 
-import numpy as np
-
+from typing import Any, Tuple
 from warnings import warn
-import pyopencl._cl as _cl
+
+import numpy as np
 from pytools.persistent_dict import WriteOncePersistentDict
 from pytools.py_codegen import Indentation, PythonCodeGenerator
-from pyopencl.tools import _NumpyTypesKeyBuilder, VectorArg
+
 import pyopencl as cl
+import pyopencl._cl as _cl
+from pyopencl.tools import VectorArg, _NumpyTypesKeyBuilder
 
 
 # {{{ arg packing helpers
@@ -373,10 +375,13 @@ def _check_arg_size(function_name, num_cl_args, arg_types, devs):
 # }}}
 
 
-invoker_cache = WriteOncePersistentDict(
-        "pyopencl-invoker-cache-v41",
-        key_builder=_NumpyTypesKeyBuilder(),
-        in_mem_cache_size=0)
+if not cl._PYOPENCL_NO_CACHE:
+    from pytools.py_codegen import PicklableModule
+    invoker_cache: WriteOncePersistentDict[Any, Tuple[PicklableModule, str]] \
+        = WriteOncePersistentDict(
+            "pyopencl-invoker-cache-v42-nano",
+            key_builder=_NumpyTypesKeyBuilder(),
+            in_mem_cache_size=0)
 
 
 def generate_enqueue_and_set_args(function_name,
@@ -400,7 +405,8 @@ def generate_enqueue_and_set_args(function_name,
 
     if not from_cache:
         pmod, enqueue_name = _generate_enqueue_and_set_args_module(*cache_key)
-        invoker_cache.store_if_not_present(cache_key, (pmod, enqueue_name))
+        if not cl._PYOPENCL_NO_CACHE:
+            invoker_cache.store_if_not_present(cache_key, (pmod, enqueue_name))
 
     return (
             pmod.mod_globals[enqueue_name],

pyopencl/ipython_ext.py

@@ -1,4 +1,4 @@
-from IPython.core.magic import (magics_class, Magics, cell_magic, line_magic)
+from IPython.core.magic import Magics, cell_magic, line_magic, magics_class
 
 import pyopencl as cl
 

pyopencl/reduction.py

@@ -35,9 +35,8 @@ import numpy as np
 
 import pyopencl as cl
 from pyopencl.tools import (
-        DtypedArgument, KernelTemplateBase,
-        context_dependent_memoize, dtype_to_ctype,
-        _process_code_for_macro)
+    DtypedArgument, KernelTemplateBase, _process_code_for_macro,
+    context_dependent_memoize, dtype_to_ctype)
 
 
 # {{{ kernel source
@@ -177,6 +176,7 @@ def _get_reduction_source(
     # }}}
 
     from mako.template import Template
+
     from pyopencl.characterize import has_double_support
 
     arguments = ", ".join(arg.declarator() for arg in parsed_args)
@@ -219,8 +219,8 @@ def get_reduction_kernel(
         map_expr = "pyopencl_reduction_inp[i]" if stage == 2 else "in[i]"
 
     from pyopencl.tools import (
-            parse_arg_list, get_arg_list_scalar_arg_dtypes,
-            get_arg_offset_adjuster_code, VectorArg)
+        VectorArg, get_arg_list_scalar_arg_dtypes, get_arg_offset_adjuster_code,
+        parse_arg_list)
 
     if arguments is None:
         raise ValueError("arguments must not be None")