pyopencl 2024.2.2__cp310-cp310-win_amd64.whl → 2024.2.5__cp310-cp310-win_amd64.whl

pyopencl-2024.2.2.data/data/examples/demo-struct-reduce.py

@@ -1,75 +0,0 @@
-import numpy as np
-
-import pyopencl as cl
-
-
-def make_collector_dtype(device):
-    dtype = np.dtype([
-        ("cur_min", np.int32),
-        ("cur_max", np.int32),
-        ("pad", np.int32),
-        ])
-
-    name = "minmax_collector"
-    from pyopencl.tools import get_or_register_dtype, match_dtype_to_c_struct
-
-    dtype, c_decl = match_dtype_to_c_struct(device, name, dtype)
-    dtype = get_or_register_dtype(name, dtype)
-
-    return dtype, c_decl
-
-
-ctx = cl.create_some_context()
-queue = cl.CommandQueue(ctx)
-
-mmc_dtype, mmc_c_decl = make_collector_dtype(ctx.devices[0])
-
-preamble = mmc_c_decl + r"""//CL//
-
-    minmax_collector mmc_neutral()
-    {
-        // FIXME: needs infinity literal in real use, ok here
-        minmax_collector result;
-        result.cur_min = 1<<30;
-        result.cur_max = -(1<<30);
-        return result;
-    }
-
-    minmax_collector mmc_from_scalar(float x)
-    {
-        minmax_collector result;
-        result.cur_min = x;
-        result.cur_max = x;
-        return result;
-    }
-
-    minmax_collector agg_mmc(minmax_collector a, minmax_collector b)
-    {
-        minmax_collector result = a;
-        if (b.cur_min < result.cur_min)
-            result.cur_min = b.cur_min;
-        if (b.cur_max > result.cur_max)
-            result.cur_max = b.cur_max;
-        return result;
-    }
-
-    """
-
-from pyopencl.clrandom import rand as clrand
-
-
-a_gpu = clrand(queue, (20000,), dtype=np.int32, a=0, b=10**6)
-a = a_gpu.get()
-
-from pyopencl.reduction import ReductionKernel
-
-
-red = ReductionKernel(ctx, mmc_dtype,
-        neutral="mmc_neutral()",
-        reduce_expr="agg_mmc(a, b)", map_expr="mmc_from_scalar(x[i])",
-        arguments="__global int *x", preamble=preamble)
-
-minmax = red(a_gpu).get()
-
-assert abs(minmax["cur_min"] - np.min(a)) < 1e-5
-assert abs(minmax["cur_max"] - np.max(a)) < 1e-5

pyopencl-2024.2.2.data/data/examples/demo.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python
-
-import numpy as np
-
-import pyopencl as cl
-
-
-rng = np.random.default_rng()
-a_np = rng.random(50000, dtype=np.float32)
-b_np = rng.random(50000, dtype=np.float32)
-
-ctx = cl.create_some_context()
-queue = cl.CommandQueue(ctx)
-
-mf = cl.mem_flags
-a_g = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=a_np)
-b_g = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=b_np)
-
-prg = cl.Program(ctx, """
-__kernel void sum(
-    __global const float *a_g, __global const float *b_g, __global float *res_g)
-{
-  int gid = get_global_id(0);
-  res_g[gid] = a_g[gid] + b_g[gid];
-}
-""").build()
-
-res_g = cl.Buffer(ctx, mf.WRITE_ONLY, a_np.nbytes)
-knl = prg.sum  # Use this Kernel object for repeated calls
-knl(queue, a_np.shape, None, a_g, b_g, res_g)
-
-res_np = np.empty_like(a_np)
-cl.enqueue_copy(queue, res_np, res_g)
-
-# Check on CPU with Numpy:
-error_np = res_np - (a_np + b_np)
-print(f"Error:\n{error_np}")
-print(f"Norm: {np.linalg.norm(error_np):.16e}")
-assert np.allclose(res_np, a_np + b_np)

pyopencl-2024.2.2.data/data/examples/demo_array.py

@@ -1,32 +0,0 @@
-import numpy as np
-import numpy.linalg as la
-
-import pyopencl as cl
-import pyopencl.array as cl_array
-
-
-rng = np.random.default_rng()
-a = rng.random(50000, dtype=np.float32)
-b = rng.random(50000, dtype=np.float32)
-
-ctx = cl.create_some_context()
-queue = cl.CommandQueue(ctx)
-
-a_dev = cl_array.to_device(queue, a)
-b_dev = cl_array.to_device(queue, b)
-dest_dev = cl_array.empty_like(a_dev)
-
-prg = cl.Program(ctx, """
-    __kernel void sum(__global const float *a,
-    __global const float *b, __global float *c)
-    {
-      int gid = get_global_id(0);
-      c[gid] = a[gid] + b[gid];
-    }
-    """).build()
-
-knl = prg.sum  # Use this Kernel object for repeated calls
-knl(queue, a.shape, None, a_dev.data, b_dev.data, dest_dev.data)
-
-print(la.norm((dest_dev - (a_dev+b_dev)).get()))
-assert np.allclose(dest_dev.get(), (a_dev + b_dev).get())

pyopencl-2024.2.2.data/data/examples/demo_array_svm.py

@@ -1,37 +0,0 @@
-import numpy as np
-
-import pyopencl as cl
-import pyopencl.array as cl_array
-from pyopencl.tools import SVMAllocator, SVMPool
-
-
-n = 50000
-
-rng = np.random.default_rng()
-a = rng.random(n, dtype=np.float32)
-b = rng.random(n, dtype=np.float32)
-
-ctx = cl.create_some_context()
-queue = cl.CommandQueue(ctx)
-
-alloc = SVMAllocator(ctx, alignment=0, queue=queue)
-alloc = SVMPool(alloc)
-
-a_dev = cl_array.to_device(queue, a, allocator=alloc)
-b_dev = cl_array.to_device(queue, b, allocator=alloc)
-dest_dev = cl_array.empty_like(a_dev)
-
-prg = cl.Program(ctx, """
-    __kernel void sum(__global const float *a,
-    __global const float *b, __global float *c)
-    {
-      int gid = get_global_id(0);
-      c[gid] = a[gid] + b[gid];
-    }
-    """).build()
-
-knl = prg.sum
-knl(queue, a.shape, None, a_dev.data, b_dev.data, dest_dev.data)
-
-print(np.linalg.norm((dest_dev - (a_dev + b_dev)).get()))
-assert np.allclose(dest_dev.get(), (a_dev + b_dev).get())

pyopencl-2024.2.2.data/data/examples/demo_elementwise.py

@@ -1,34 +0,0 @@
-import numpy as np
-
-import pyopencl as cl
-import pyopencl.array
-from pyopencl.elementwise import ElementwiseKernel
-
-
-n = 10
-
-rng = np.random.default_rng()
-a_np = rng.random(n, dtype=np.float32)
-b_np = rng.random(n, dtype=np.float32)
-
-ctx = cl.create_some_context()
-queue = cl.CommandQueue(ctx)
-
-a_g = cl.array.to_device(queue, a_np)
-b_g = cl.array.to_device(queue, b_np)
-
-lin_comb = ElementwiseKernel(ctx,
-    "float k1, float *a_g, float k2, float *b_g, float *res_g",
-    "res_g[i] = k1 * a_g[i] + k2 * b_g[i]",
-    "lin_comb")
-
-res_g = cl.array.empty_like(a_g)
-lin_comb(2, a_g, 3, b_g, res_g)
-
-# Check on GPU with PyOpenCL Array:
-print((res_g - (2 * a_g + 3 * b_g)).get())
-
-# Check on CPU with Numpy:
-res_np = res_g.get()
-print(res_np - (2 * a_np + 3 * b_np))
-print(np.linalg.norm(res_np - (2 * a_np + 3 * b_np)))

pyopencl-2024.2.2.data/data/examples/demo_elementwise_complex.py

@@ -1,53 +0,0 @@
-import numpy as np
-import numpy.linalg as la
-
-import pyopencl as cl
-import pyopencl.array as cl_array
-from pyopencl.elementwise import ElementwiseKernel
-
-
-ctx = cl.create_some_context()
-queue = cl.CommandQueue(ctx)
-
-n = 10
-
-rng = np.random.default_rng()
-a_gpu = cl_array.to_device(queue,
-        rng.standard_normal(n, dtype=np.float32)
-        + 1j*rng.standard_normal(n, dtype=np.float32))
-b_gpu = cl_array.to_device(queue,
-        rng.standard_normal(n, dtype=np.float32)
-        + 1j*rng.standard_normal(n, dtype=np.float32))
-
-complex_prod = ElementwiseKernel(ctx,
-        "float a, "
-        "cfloat_t *x, "
-        "cfloat_t *y, "
-        "cfloat_t *z",
-        "z[i] = cfloat_rmul(a, cfloat_mul(x[i], y[i]))",
-        "complex_prod",
-        preamble="#include <pyopencl-complex.h>")
-
-complex_add = ElementwiseKernel(ctx,
-        "cfloat_t *x, "
-        "cfloat_t *y, "
-        "cfloat_t *z",
-        "z[i] = cfloat_add(x[i], y[i])",
-        "complex_add",
-        preamble="#include <pyopencl-complex.h>")
-
-real_part = ElementwiseKernel(ctx,
-        "cfloat_t *x, float *z",
-        "z[i] = cfloat_real(x[i])",
-        "real_part",
-        preamble="#include <pyopencl-complex.h>")
-
-c_gpu = cl_array.empty_like(a_gpu)
-complex_prod(5, a_gpu, b_gpu, c_gpu)
-
-c_gpu_real = cl_array.empty(queue, len(a_gpu), dtype=np.float32)
-real_part(c_gpu, c_gpu_real)
-print(c_gpu.get().real - c_gpu_real.get())
-
-print(la.norm(c_gpu.get() - (5*a_gpu.get()*b_gpu.get())))
-assert la.norm(c_gpu.get() - (5*a_gpu.get()*b_gpu.get())) < 1e-5

pyopencl-2024.2.2.data/data/examples/demo_mandelbrot.py

@@ -1,183 +0,0 @@
-# I found this example for PyCuda here:
-# http://wiki.tiker.net/PyCuda/Examples/Mandelbrot
-#
-# An improved sequential/pure Python code was contributed
-# by CRVSADER//KY <crusaderky@gmail.com>.
-#
-# I adapted it for PyOpenCL. Hopefully it is useful to someone.
-# July 2010, HolgerRapp@gmx.net
-#
-# Original readme below these lines.
-
-# Mandelbrot calculate using GPU, Serial numpy and faster numpy
-# Use to show the speed difference between CPU and GPU calculations
-# ian@ianozsvald.com March 2010
-
-# Based on vegaseat's TKinter/numpy example code from 2006
-# http://www.daniweb.com/code/snippet216851.html#
-# with minor changes to move to numpy from the obsolete Numeric
-
-import time
-
-import numpy as np
-from PIL import Image
-
-import pyopencl as cl
-
-
-# You can choose a calculation routine below (calc_fractal), uncomment
-# one of the three lines to test the three variations
-# Speed notes are listed in the same place
-
-# set width and height of window, more pixels take longer to calculate
-w = 2048
-h = 2048
-
-
-def calc_fractal_opencl(q, maxiter):
-    ctx = cl.create_some_context()
-    queue = cl.CommandQueue(ctx)
-
-    output = np.empty(q.shape, dtype=np.uint16)
-
-    mf = cl.mem_flags
-    q_opencl = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=q)
-    output_opencl = cl.Buffer(ctx, mf.WRITE_ONLY, output.nbytes)
-
-    prg = cl.Program(
-        ctx,
-        """
-    #pragma OPENCL EXTENSION cl_khr_byte_addressable_store : enable
-    __kernel void mandelbrot(__global float2 *q,
-                     __global ushort *output, ushort const maxiter)
-    {
-        int gid = get_global_id(0);
-        float nreal, real = 0;
-        float imag = 0;
-
-        output[gid] = 0;
-
-        for(int curiter = 0; curiter < maxiter; curiter++) {
-            nreal = real*real - imag*imag + q[gid].x;
-            imag = 2* real*imag + q[gid].y;
-            real = nreal;
-
-            if (real*real + imag*imag > 4.0f) {
-                 output[gid] = curiter;
-                 break;
-            }
-        }
-    }
-    """,
-    ).build()
-
-    prg.mandelbrot(
-        queue, output.shape, None, q_opencl, output_opencl, np.uint16(maxiter)
-    )
-
-    cl.enqueue_copy(queue, output, output_opencl).wait()
-
-    return output
-
-
-def calc_fractal_serial(q, maxiter):
-    # calculate z using pure python on a numpy array
-    # note that, unlike the other two implementations,
-    # the number of iterations per point is NOT constant
-    z = np.zeros(q.shape, complex)
-    output = np.resize(
-        np.array(
-            0,
-        ),
-        q.shape,
-    )
-    for i in range(len(q)):
-        for iter in range(maxiter):
-            z[i] = z[i] * z[i] + q[i]
-            if abs(z[i]) > 2.0:
-                output[i] = iter
-                break
-    return output
-
-
-def calc_fractal_numpy(q, maxiter):
-    # calculate z using numpy, this is the original
-    # routine from vegaseat's URL
-    output = np.resize(
-        np.array(
-            0,
-        ),
-        q.shape,
-    )
-    z = np.zeros(q.shape, np.complex64)
-
-    for it in range(maxiter):
-        z = z * z + q
-        done = np.greater(abs(z), 2.0)
-        q = np.where(done, 0 + 0j, q)
-        z = np.where(done, 0 + 0j, z)
-        output = np.where(done, it, output)
-    return output
-
-
-# choose your calculation routine here by uncommenting one of the options
-calc_fractal = calc_fractal_opencl
-# calc_fractal = calc_fractal_serial
-# calc_fractal = calc_fractal_numpy
-
-
-class Mandelbrot:
-    def draw(self, x1, x2, y1, y2, maxiter=30):
-        # draw the Mandelbrot set, from numpy example
-        xx = np.arange(x1, x2, (x2 - x1) / w)
-        yy = np.arange(y2, y1, (y1 - y2) / h) * 1j
-        q = np.ravel(xx + yy[:, np.newaxis]).astype(np.complex64)
-
-        start_main = time.time()
-        output = calc_fractal(q, maxiter)
-        end_main = time.time()
-
-        secs = end_main - start_main
-        print("Main took", secs)
-
-        self.mandel = (output.reshape((h, w)) / float(output.max()) * 255.0).astype(
-            np.uint8
-        )
-
-    def create_image(self):
-        """ "
-        create the image from the draw() string
-        """
-        # you can experiment with these x and y ranges
-        self.draw(-2.13, 0.77, -1.3, 1.3)
-        self.im = Image.fromarray(self.mandel)
-        self.im.putpalette([i for rgb in ((j, 0, 0) for j in range(255))
-            for i in rgb])
-
-    def create_label(self):
-        # put the image on a label widget
-        self.image = ImageTk.PhotoImage(self.im)
-        self.label = tk.Label(self.root, image=self.image)
-        self.label.pack()
-
-    def run_tk(self):
-        self.root = tk.Tk()
-        self.root.title("Mandelbrot Set")
-        self.create_image()
-        self.create_label()
-        # start event loop
-        self.root.mainloop()
-
-
-if __name__ == "__main__":
-    test = Mandelbrot()
-    try:
-        import tkinter as tk
-    except ModuleNotFoundError:
-        test.create_image()
-    else:
-        from PIL import ImageTk
-        try:
-            test.run_tk()
-        except tk.TclError:
-            test.create_image()

pyopencl-2024.2.2.data/data/examples/demo_meta_codepy.py

@@ -1,56 +0,0 @@
-import numpy as np
-import numpy.linalg as la
-from cgen import (
-    POD, Assign, Block, Const, FunctionBody, FunctionDeclaration, Initializer,
-    Module, Pointer, Value)
-from cgen.opencl import CLGlobal, CLKernel, CLRequiredWorkGroupSize
-
-import pyopencl as cl
-
-
-local_size = 256
-thread_strides = 32
-macroblock_count = 33
-dtype = np.float32
-total_size = local_size*thread_strides*macroblock_count
-
-ctx = cl.create_some_context()
-queue = cl.CommandQueue(ctx)
-
-rng = np.random.default_rng()
-a = rng.standard_normal(total_size, dtype=dtype)
-b = rng.standard_normal(total_size, dtype=dtype)
-
-mf = cl.mem_flags
-a_buf = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=a)
-b_buf = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=b)
-c_buf = cl.Buffer(ctx, mf.WRITE_ONLY, b.nbytes)
-
-mod = Module([
-    FunctionBody(
-        CLKernel(CLRequiredWorkGroupSize((local_size,),
-            FunctionDeclaration(
-            Value("void", "add"),
-            arg_decls=[CLGlobal(Pointer(Const(POD(dtype, name))))
-                for name in ["tgt", "op1", "op2"]]))),
-        Block([
-            Initializer(POD(np.int32, "idx"),
-                "get_local_id(0) + %d * get_group_id(0)"
-                % (local_size*thread_strides))
-            ]+[
-            Assign(
-                "tgt[idx+%d]" % (o*local_size),
-                "op1[idx+%d] + op2[idx+%d]" % (
-                    o*local_size,
-                    o*local_size))
-            for o in range(thread_strides)]))])
-
-knl = cl.Program(ctx, str(mod)).build().add
-
-knl(queue, (local_size*macroblock_count,), (local_size,),
-        c_buf, a_buf, b_buf)
-
-c = np.empty_like(a)
-cl.enqueue_copy(queue, c, c_buf).wait()
-
-assert la.norm(c-(a+b)) == 0

pyopencl-2024.2.2.data/data/examples/demo_meta_template.py

@@ -1,55 +0,0 @@
-import numpy as np
-import numpy.linalg as la
-from mako.template import Template
-
-import pyopencl as cl
-
-
-local_size = 256
-thread_strides = 32
-macroblock_count = 33
-dtype = np.float32
-total_size = local_size*thread_strides*macroblock_count
-
-ctx = cl.create_some_context()
-queue = cl.CommandQueue(ctx)
-
-rng = np.random.default_rng()
-a = rng.standard_normal(total_size, dtype=dtype)
-b = rng.standard_normal(total_size, dtype=dtype)
-
-mf = cl.mem_flags
-a_buf = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=a)
-b_buf = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=b)
-c_buf = cl.Buffer(ctx, mf.WRITE_ONLY, b.nbytes)
-
-tpl = Template("""
-    __kernel void add(
-            __global ${ type_name } *tgt,
-            __global const ${ type_name } *op1,
-            __global const ${ type_name } *op2)
-    {
-      int idx = get_local_id(0)
-        + ${ local_size } * ${ thread_strides }
-        * get_group_id(0);
-
-      % for i in range(thread_strides):
-          <% offset = i*local_size %>
-          tgt[idx + ${ offset }] =
-            op1[idx + ${ offset }]
-            + op2[idx + ${ offset } ];
-      % endfor
-    }""")
-
-rendered_tpl = tpl.render(type_name="float",
-    local_size=local_size, thread_strides=thread_strides)
-
-knl = cl.Program(ctx, str(rendered_tpl)).build().add
-
-knl(queue, (local_size*macroblock_count,), (local_size,),
-        c_buf, a_buf, b_buf)
-
-c = np.empty_like(a)
-cl.enqueue_copy(queue, c, c_buf).wait()
-
-assert la.norm(c-(a+b)) == 0

pyopencl-2024.2.2.data/data/examples/dump-performance.py

@@ -1,38 +0,0 @@
-import pyopencl as cl
-import pyopencl.characterize.performance as perf
-
-
-def main():
-    ctx = cl.create_some_context()
-
-    prof_overhead, latency = perf.get_profiling_overhead(ctx)
-    print("command latency: %g s" % latency)
-    print("profiling overhead: {:g} s -> {:.1f} %".format(
-            prof_overhead, 100*prof_overhead/latency))
-    queue = cl.CommandQueue(
-            ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
-
-    print("empty kernel: %g s" % perf.get_empty_kernel_time(queue))
-    print("float32 add: %g GOps/s" % (perf.get_add_rate(queue)/1e9))
-
-    for tx_type in [
-            perf.HostToDeviceTransfer,
-            perf.DeviceToHostTransfer,
-            perf.DeviceToDeviceTransfer]:
-        print("----------------------------------------")
-        print(tx_type.__name__)
-        print("----------------------------------------")
-
-        print("latency: %g s" % perf.transfer_latency(queue, tx_type))
-        for i in range(6, 31, 2):
-            bs = 1 << i
-            try:
-                result = "%g GB/s" % (
-                        perf.transfer_bandwidth(queue, tx_type, bs)/1e9)
-            except Exception as e:
-                result = "exception: %s" % e.__class__.__name__
-            print("bandwidth @ %d bytes: %s" % (bs, result))
-
-
-if __name__ == "__main__":
-    main()

pyopencl-2024.2.2.data/data/examples/dump-properties.py

@@ -1,86 +0,0 @@
-from optparse import OptionParser
-
-import pyopencl as cl
-
-
-parser = OptionParser()
-parser.add_option("-s", "--short", action="store_true",
-                  help="don't print all device properties")
-
-(options, args) = parser.parse_args()
-
-
-def print_info(obj, info_cls):
-    for info_name in sorted(dir(info_cls)):
-        if not info_name.startswith("_") and info_name != "to_string":
-            info = getattr(info_cls, info_name)
-            try:
-                info_value = obj.get_info(info)
-            except Exception:
-                info_value = "<error>"
-
-            if (info_cls == cl.device_info and info_name == "PARTITION_TYPES_EXT"
-                    and isinstance(info_value, list)):
-                print("{}: {}".format(info_name, [
-                    cl.device_partition_property_ext.to_string(v,
-                        "<unknown device partition property %d>")
-                    for v in info_value]))
-            else:
-                try:
-                    print(f"{info_name}: {info_value}")
-                except Exception:
-                    print("%s: <error>" % info_name)
-
-
-for platform in cl.get_platforms():
-    print(75*"=")
-    print(platform)
-    print(75*"=")
-    if not options.short:
-        print_info(platform, cl.platform_info)
-
-    for device in platform.get_devices():
-        if not options.short:
-            print(75*"-")
-        print(device)
-        if not options.short:
-            print(75*"-")
-            print_info(device, cl.device_info)
-            ctx = cl.Context([device])
-            for mf in [
-                    cl.mem_flags.READ_ONLY,
-                    #cl.mem_flags.READ_WRITE,
-                    #cl.mem_flags.WRITE_ONLY
-                    ]:
-                for itype in [
-                        cl.mem_object_type.IMAGE2D,
-                        cl.mem_object_type.IMAGE3D
-                        ]:
-                    try:
-                        formats = cl.get_supported_image_formats(ctx, mf, itype)
-                    except Exception:
-                        formats = "<error>"
-                    else:
-                        def str_chd_type(chdtype):
-                            result = cl.channel_type.to_string(chdtype,
-                                    "<unknown channel data type %d>")
-
-                            result = result.replace("_INT", "")
-                            result = result.replace("UNSIGNED", "U")
-                            result = result.replace("SIGNED", "S")
-                            result = result.replace("NORM", "N")
-                            result = result.replace("FLOAT", "F")
-                            return result
-
-                        formats = ", ".join(
-                                "{}-{}".format(
-                                    cl.channel_order.to_string(iform.channel_order,
-                                        "<unknown channel order 0x%x>"),
-                                    str_chd_type(iform.channel_data_type))
-                                for iform in formats)
-
-                    print("{} {} FORMATS: {}\n".format(
-                            cl.mem_object_type.to_string(itype),
-                            cl.mem_flags.to_string(mf),
-                            formats))
-            del ctx