6794434213

Committed 08 Nov 2023 06:07AM UTC coverage: 78.56% (-0.03%) from 78.594%

Build # 6794434213

Build Type

Pull #1144

github

Committed by

web-flow

Commit Message

Merge 4ccfaa09c into fe619d074

Pull Request Pull Request #1144: Implement support for dpnp.arange()

Run Details

1191 of 1793 branches covered (0.0%)

Branch coverage included in aggregate %.

154 of 190 new or added lines in 3 files covered. (81.05%)

8 existing lines in 1 file now uncovered.

5192 of 6332 relevant lines covered (82.0%)

0.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.67

/numba_dpex/dpnp_iface/array_sequence_ops.py

# SPDX-FileCopyrightText: 2020 - 2023 Intel Corporation
#
# SPDX-License-Identifier: Apache-2.0

from collections import namedtuple

import dpnp
import numba
from llvmlite import ir as llvmir
from llvmlite.ir import types as llvmirtypes
from numba import errors, types
from numba.core import cgutils
from numba.core.types.misc import NoneType
from numba.core.types.scalars import Boolean, Complex, Float, Integer
from numba.extending import intrinsic, overload
from numba.np.numpy_support import is_nonelike

import numba_dpex.utils as utils
from numba_dpex.core.types import DpnpNdArray
from numba_dpex.dpnp_iface._intrinsic import (
    _ArgTyAndValue,
    _empty_nd_impl,
    _get_queue_ref,
)
from numba_dpex.dpnp_iface.arrayobj import (
    _parse_device_filter_string,
    _parse_dtype,
    _parse_usm_type,
)

_QueueRefPayload = namedtuple(
    "QueueRefPayload", ["queue_ref", "py_dpctl_sycl_queue_addr", "pyapi"]
)


def _is_float_type(start, stop, step):
    return (
        type(start) == float
        or type(stop) == float
        or type(step) == float
        or isinstance(start, Float)
        or isinstance(stop, Float)
        or isinstance(step, Float)
    )


def _is_int_type(start, stop, step):
    return (
        type(start) == int
        or type(stop) == int
        or type(step) == int
        or isinstance(start, Integer)
        or isinstance(stop, Integer)
        or isinstance(step, Integer)
    )


def _is_complex_type(start, stop, step):
    return (
        isinstance(start, Complex)
        or isinstance(stop, Complex)
        or isinstance(step, Complex)
    )


def _parse_dtype_from_range(start, stop, step):
    if _is_complex_type(start, stop, step):
        return numba.from_dtype(dpnp.complex128)
    elif _is_float_type(start, stop, step):
        return numba.from_dtype(dpnp.float64)
    elif _is_int_type(start, stop, step):
        return numba.from_dtype(dpnp.int64)
    else:
        msg = (
            "dpnp_iface.array_sequence_ops._parse_dtype_from_range(): "
            + "Types couldn't be inferred for (start, stop, step)."
        )
        raise errors.NumbaValueError(msg)


def _get_llvm_type(numba_type):
    if isinstance(numba_type, Integer):
        return llvmir.IntType(numba_type.bitwidth)
    elif isinstance(numba_type, Float):
        if numba_type.bitwidth == 64:
            return llvmir.DoubleType()
        elif numba_type.bitwidth == 32:
            return llvmir.FloatType()
        elif numba_type.bitwidth == 16:
            return llvmir.HalfType()
        else:
            msg = (
                "dpnp_iface.array_sequence_ops._get_llvm_type(): "
                + f"Incompatible bitwidth in {numba_type}."
            )
            raise errors.NumbaTypeError(msg)
    else:
        msg = (
            "dpnp_iface.array_sequence_ops._get_llvm_type(): "
            + "Incompatible numba type."
        )
        raise errors.NumbaTypeError(msg)


def _get_dst_typeid(dtype):
    if isinstance(dtype, Boolean):
        return 0
    elif isinstance(dtype, Integer):
        if dtype.bitwidth == 8:
            return 1 if dtype.signed else 2
        elif dtype.bitwidth == 16:
            return 3 if dtype.signed else 4
        elif dtype.bitwidth == 32:
            return 5 if dtype.signed else 6
        elif dtype.bitwidth == 64:
            return 7 if dtype.signed else 8
        else:
            msg = (
                "dpnp_iface.array_sequence_ops._get_dst_typeid(): "
                + f"Couldn't map {dtype} to dst_index."
            )
            raise errors.NumbaValueError(msg)
    elif isinstance(dtype, Float):
        if dtype.bitwidth == 16:
            return 9
        elif dtype.bitwidth == 32:
            return 10
        elif dtype.bitwidth == 64:
            return 11
        else:
            msg = (
                "dpnp_iface.array_sequence_ops._get_dst_typeid(): "
                + f"Couldn't map {dtype} to dst_index."
            )
            raise errors.NumbaValueError(msg)
    elif isinstance(dtype, Complex):
        if dtype.bitwidth == 64:
            return 12
        elif dtype.bitwidth == 128:
            return 13
        else:
            msg = (
                "dpnp_iface.array_sequence_ops._get_dst_typeid(): "
                + f"Couldn't map {dtype} to dst_index."
            )
            raise errors.NumbaValueError(msg)
    else:
        msg = (
            "dpnp_iface.array_sequence_ops._get_dst_typeid(): "
            + f"Unknown numba type {dtype}"
        )
        raise errors.NumbaTypeError(msg)


def _round(builder, src, src_type):
    return_type = (
        llvmirtypes.DoubleType()
        if src_type.bitwidth == 64
        else (
            llvmirtypes.FloatType()
            if src_type.bitwidth == 32
            else llvmirtypes.HalfType()
        )
    )
    round = builder.module.declare_intrinsic("llvm.round", [return_type])
    src = builder.call(round, [src])
    return src


def _is_fraction(builder, src, src_type):
    if isinstance(src_type, Float):
        return_type = (
            llvmirtypes.DoubleType()
            if src_type.bitwidth == 64
            else (
                llvmirtypes.FloatType()
                if src_type.bitwidth == 32
                else llvmirtypes.HalfType()
            )
        )
        llvm_fabs = builder.module.declare_intrinsic("llvm.fabs", [return_type])
        src_abs = builder.call(llvm_fabs, [src])
        ret = True
        is_lto = builder.fcmp_ordered(">=", src_abs, src.type(1.0))
        with builder.if_then(is_lto):
            ret = False
        return ret


def _normalize(builder, src, src_type, dest_type, rounding=False):
    dest_llvm_type = _get_llvm_type(dest_type)
    if isinstance(src_type, Integer) and isinstance(dest_type, Integer):
        if src_type.bitwidth < dest_type.bitwidth:
            return builder.zext(src, dest_llvm_type)
        elif src_type.bitwidth > dest_type.bitwidth:
            return builder.trunc(src, dest_llvm_type)
        else:
            return src
    elif isinstance(src_type, Integer) and isinstance(dest_type, Float):
        if src_type.signed:
            return builder.sitofp(src, dest_llvm_type)
        else:
            return builder.uitofp(src, dest_llvm_type)
    elif isinstance(src_type, Float) and isinstance(dest_type, Integer):
        if rounding:
            src = _round(builder, src, src_type)
        if dest_type.signed:
            return builder.fptosi(src, dest_llvm_type)
        else:
            return builder.fptoui(src, dest_llvm_type)
    elif isinstance(src_type, Float) and isinstance(dest_type, Float):
        if src_type.bitwidth < dest_type.bitwidth:
            return builder.fpext(src, dest_llvm_type)
        elif src_type.bitwidth > dest_type.bitwidth:
            return builder.fptrunc(src, dest_llvm_type)
        else:
            return src
    else:
        msg = (
            "dpnp_iface.array_sequence_ops._normalize(): "
            + f"{src}[{src_type}] is neither a "
            + "'numba.core.types.scalars.Float' "
            + "nor an 'numba.core.types.scalars.Integer'."
        )
        raise errors.NumbaTypeError(msg)


def _compute_array_length_ir(
    builder,
    start_ir,
    stop_ir,
    step_ir,
    start_arg_type,
    stop_arg_type,
    step_arg_type,
):
    lb = _normalize(builder, start_ir, start_arg_type, types.float64)
    ub = _normalize(builder, stop_ir, stop_arg_type, types.float64)
    n = _normalize(builder, step_ir, step_arg_type, types.float64)

    llvm_ceil = builder.module.declare_intrinsic(
        "llvm.ceil", [llvmirtypes.DoubleType()]
    )

    array_length_ir = builder.fptosi(
        builder.call(
            llvm_ceil,
            [builder.fdiv(builder.fsub(ub, lb), n)],
        ),
        llvmir.IntType(64),
    )

    return array_length_ir


@intrinsic
def impl_dpnp_arange(
    ty_context,
    ty_start,
    ty_stop,
    ty_step,
    ty_dtype,
    ty_device,
    ty_usm_type,
    ty_sycl_queue,
    ty_ret_ty,
):
    ty_retty_ = ty_ret_ty.instance_type
    signature = ty_retty_(
        ty_start,
        ty_stop,
        ty_step,
        ty_dtype,
        ty_device,
        ty_usm_type,
        ty_sycl_queue,
        ty_ret_ty,
    )

    sycl_queue_arg_pos = -2

    def codegen(context, builder, sig, args):
        # Rename variables for easy coding
        start_ir, stop_ir, step_ir, queue_ir = (
            args[0],
            args[1],
            args[2],
            args[sycl_queue_arg_pos],
        )
        (
            start_arg_type,
            stop_arg_type,
            step_arg_type,
            dtype_arg_type,
            queue_arg_type,
        ) = (
            sig.args[0],
            sig.args[1],
            sig.args[2],
            sig.args[3],
            sig.args[sycl_queue_arg_pos],
        )

        # Get SYCL Queue ref
        sycl_queue_arg = _ArgTyAndValue(queue_arg_type, queue_ir)
        qref_payload: _QueueRefPayload = _get_queue_ref(
            context=context,
            builder=builder,
            returned_sycl_queue_ty=sig.return_type.queue,
            sycl_queue_arg=sycl_queue_arg,
        )

        # Sanity check:
        # if stop is pointing to a null
        #    start <- 0
        #    stop <- 1
        # if step is pointing to a null
        #    step <- 1
        if isinstance(stop_arg_type, NoneType):
            start_ir = context.get_constant(start_arg_type, 0)
            stop_ir = context.get_constant(start_arg_type, 1)
            stop_arg_type = start_arg_type
        if isinstance(step_arg_type, NoneType):
            step_ir = context.get_constant(start_arg_type, 1)
            step_arg_type = start_arg_type

        # Keep note if either start or stop is in (-1.0, 0.0] or [0.0, 1.0)
        round_step = not (
            _is_fraction(builder, start_ir, start_arg_type)
            and _is_fraction(builder, stop_ir, stop_arg_type)
        )

        # Allocate an empty array
        len = _compute_array_length_ir(
            builder,
            start_ir,
            stop_ir,
            step_ir,
            start_arg_type,
            stop_arg_type,
            step_arg_type,
        )
        ary = _empty_nd_impl(
            context, builder, sig.return_type, [len], qref_payload.queue_ref
        )
        # Convert into void*
        arrystruct_vptr = builder.bitcast(ary._getpointer(), cgutils.voidptr_t)

        # Extend or truncate input values w.r.t. destination array type
        start_ir = _normalize(
            builder, start_ir, start_arg_type, dtype_arg_type.dtype
        )
        stop_ir = _normalize(
            builder, stop_ir, stop_arg_type, dtype_arg_type.dtype
        )
        step_ir = _normalize(
            builder,
            step_ir,
            step_arg_type,
            dtype_arg_type.dtype,
            rounding=round_step,
        )

        # After normalization, their arg_types will change
        start_arg_type = dtype_arg_type.dtype
        stop_arg_type = dtype_arg_type.dtype
        step_arg_type = dtype_arg_type.dtype

        # Construct function parameters
        with builder.goto_entry_block():
            start_ptr = cgutils.alloca_once(builder, start_ir.type)
            step_ptr = cgutils.alloca_once(builder, step_ir.type)
        builder.store(start_ir, start_ptr)
        builder.store(step_ir, step_ptr)
        start_vptr = builder.bitcast(start_ptr, cgutils.voidptr_t)
        step_vptr = builder.bitcast(step_ptr, cgutils.voidptr_t)
        ndim = context.get_constant(types.intp, 1)
        is_c_contguous = context.get_constant(types.int8, 1)
        typeid_index = _get_dst_typeid(dtype_arg_type.dtype)
        dst_typeid = context.get_constant(types.intp, typeid_index)

        # Function signature
        fnty = llvmir.FunctionType(
            utils.LLVMTypes.int64_ptr_t,
            [
                cgutils.voidptr_t,
                cgutils.voidptr_t,
                cgutils.voidptr_t,
                _get_llvm_type(types.intp),
                _get_llvm_type(types.int8),
                _get_llvm_type(types.intp),
                cgutils.voidptr_t,
            ],
        )

        # Kernel call
        fn = cgutils.get_or_insert_function(
            builder.module,
            fnty,
            "NUMBA_DPEX_SYCL_KERNEL_populate_arystruct_sequence",
        )
        builder.call(
            fn,
            [
                start_vptr,
                step_vptr,
                arrystruct_vptr,
                ndim,
                is_c_contguous,
                dst_typeid,
                qref_payload.queue_ref,
            ],
        )

        return ary._getvalue()

    return signature, codegen


@overload(dpnp.arange, prefer_literal=True)
def ol_dpnp_arange(
    start,
    stop=None,
    step=1,
    dtype=None,
    device=None,
    usm_type="device",
    sycl_queue=None,
):
    if isinstance(start, Complex) or (
        not is_nonelike(dtype) and isinstance(dtype.dtype, Complex)
    ):
        raise errors.NumbaNotImplementedError(
            "Complex type is not supported yet."
        )
    if isinstance(start, Boolean) or (
        not is_nonelike(dtype) and isinstance(dtype.dtype, Boolean)
    ):
        raise errors.NumbaTypeError(
            "Boolean is not supported by dpnp.arange()."
        )

    if is_nonelike(stop):
        start = 0 if type(start) == int or isinstance(start, Integer) else 0.0
        stop = 1 if type(start) == int or isinstance(start, Integer) else 1.0
    if is_nonelike(step):
        step = 1 if type(start) == int or isinstance(start, Integer) else 1.0

    _dtype = (
        _parse_dtype(dtype)
        if not is_nonelike(dtype)
        else _parse_dtype_from_range(start, stop, step)
    )
    _device = _parse_device_filter_string(device) if device else None
    _usm_type = _parse_usm_type(usm_type) if usm_type else "device"

    ret_ty = DpnpNdArray(
        ndim=1,
        layout="C",
        dtype=_dtype,
        usm_type=_usm_type,
        device=_device,
        queue=sycl_queue,
    )

    if ret_ty:

        def impl(
            start,
            stop=None,
            step=1,
            dtype=None,
            device=None,
            usm_type="device",
            sycl_queue=None,
        ):
            return impl_dpnp_arange(
                start,
                stop,
                step,
                _dtype,
                _device,
                _usm_type,
                sycl_queue,
                ret_ty,
            )

        return impl
    else:
        raise errors.TypingError(
            "Cannot parse input types to "
            + f"function dpnp.arange({start}, {stop}, {step}, ...)."
        )

1	# SPDX-FileCopyrightText: 2020 - 2023 Intel Corporation
2	#
3	# SPDX-License-Identifier: Apache-2.0
4
5	from collections import namedtuple	1✔
6
7	import dpnp	1✔
8	import numba	1✔
9	from llvmlite import ir as llvmir	1✔
10	from llvmlite.ir import types as llvmirtypes	1✔
11	from numba import errors, types	1✔
12	from numba.core import cgutils	1✔
13	from numba.core.types.misc import NoneType	1✔
14	from numba.core.types.scalars import Boolean, Complex, Float, Integer	1✔
15	from numba.extending import intrinsic, overload	1✔
16	from numba.np.numpy_support import is_nonelike	1✔
17
18	import numba_dpex.utils as utils	1✔
19	from numba_dpex.core.types import DpnpNdArray	1✔
20	from numba_dpex.dpnp_iface._intrinsic import (	1✔
21	_ArgTyAndValue,
22	_empty_nd_impl,
23	_get_queue_ref,
24	)
25	from numba_dpex.dpnp_iface.arrayobj import (	1✔
26	_parse_device_filter_string,
27	_parse_dtype,
28	_parse_usm_type,
29	)
30
31	_QueueRefPayload = namedtuple(	1✔
32	"QueueRefPayload", ["queue_ref", "py_dpctl_sycl_queue_addr", "pyapi"]
33	)
34
35
36	def _is_float_type(start, stop, step):	1✔
37	return (	1✔
38	type(start) == float
39	or type(stop) == float
40	or type(step) == float
41	or isinstance(start, Float)
42	or isinstance(stop, Float)
43	or isinstance(step, Float)
44	)
45
46
47	def _is_int_type(start, stop, step):	1✔
48	return (	1✔
49	type(start) == int
50	or type(stop) == int
51	or type(step) == int
52	or isinstance(start, Integer)
53	or isinstance(stop, Integer)
54	or isinstance(step, Integer)
55	)
56
57
58	def _is_complex_type(start, stop, step):	1✔
59	return (	1✔
60	isinstance(start, Complex)
61	or isinstance(stop, Complex)
62	or isinstance(step, Complex)
63	)
64
65
66	def _parse_dtype_from_range(start, stop, step):	1✔
67	if _is_complex_type(start, stop, step):	1!
NEW 68	return numba.from_dtype(dpnp.complex128)	×
69	elif _is_float_type(start, stop, step):	1✔
70	return numba.from_dtype(dpnp.float64)	1✔
71	elif _is_int_type(start, stop, step):	1!
72	return numba.from_dtype(dpnp.int64)	1✔
73	else:
NEW 74	msg = (	×
75	"dpnp_iface.array_sequence_ops._parse_dtype_from_range(): "
76	+ "Types couldn't be inferred for (start, stop, step)."
77	)
NEW 78	raise errors.NumbaValueError(msg)	×
79
80
81	def _get_llvm_type(numba_type):	1✔
82	if isinstance(numba_type, Integer):	1✔
83	return llvmir.IntType(numba_type.bitwidth)	1✔
84	elif isinstance(numba_type, Float):	1!
85	if numba_type.bitwidth == 64:	1✔
86	return llvmir.DoubleType()	1✔
87	elif numba_type.bitwidth == 32:	1!
88	return llvmir.FloatType()	1✔
NEW 89	elif numba_type.bitwidth == 16:	×
NEW 90	return llvmir.HalfType()	×
91	else:
NEW 92	msg = (	×
93	"dpnp_iface.array_sequence_ops._get_llvm_type(): "
94	+ f"Incompatible bitwidth in {numba_type}."
95	)
NEW 96	raise errors.NumbaTypeError(msg)	×
97	else:
NEW 98	msg = (	×
99	"dpnp_iface.array_sequence_ops._get_llvm_type(): "
100	+ "Incompatible numba type."
101	)
NEW 102	raise errors.NumbaTypeError(msg)	×
103
104
105	def _get_dst_typeid(dtype):	1✔
106	if isinstance(dtype, Boolean):	1!
NEW 107	return 0	×
108	elif isinstance(dtype, Integer):	1✔
109	if dtype.bitwidth == 8:	1!
NEW 110	return 1 if dtype.signed else 2	×
111	elif dtype.bitwidth == 16:	1!
NEW 112	return 3 if dtype.signed else 4	×
113	elif dtype.bitwidth == 32:	1✔
114	return 5 if dtype.signed else 6	1✔
115	elif dtype.bitwidth == 64:	1!
116	return 7 if dtype.signed else 8	1✔
117	else:
NEW 118	msg = (	×
119	"dpnp_iface.array_sequence_ops._get_dst_typeid(): "
120	+ f"Couldn't map {dtype} to dst_index."
121	)
NEW 122	raise errors.NumbaValueError(msg)	×
123	elif isinstance(dtype, Float):	1!
124	if dtype.bitwidth == 16:	1!
NEW 125	return 9	×
126	elif dtype.bitwidth == 32:	1✔
127	return 10	1✔
128	elif dtype.bitwidth == 64:	1!
129	return 11	1✔
130	else:
NEW 131	msg = (	×
132	"dpnp_iface.array_sequence_ops._get_dst_typeid(): "
133	+ f"Couldn't map {dtype} to dst_index."
134	)
NEW 135	raise errors.NumbaValueError(msg)	×
NEW 136	elif isinstance(dtype, Complex):	×
NEW 137	if dtype.bitwidth == 64:	×
NEW 138	return 12	×
NEW 139	elif dtype.bitwidth == 128:	×
NEW 140	return 13	×
141	else:
NEW 142	msg = (	×
143	"dpnp_iface.array_sequence_ops._get_dst_typeid(): "
144	+ f"Couldn't map {dtype} to dst_index."
145	)
NEW 146	raise errors.NumbaValueError(msg)	×
147	else:
NEW 148	msg = (	×
149	"dpnp_iface.array_sequence_ops._get_dst_typeid(): "
150	+ f"Unknown numba type {dtype}"
151	)
NEW 152	raise errors.NumbaTypeError(msg)	×
153
154
155	def _round(builder, src, src_type):	1✔
156	return_type = (	1✔
157	llvmirtypes.DoubleType()
158	if src_type.bitwidth == 64
159	else (
160	llvmirtypes.FloatType()
161	if src_type.bitwidth == 32
162	else llvmirtypes.HalfType()
163	)
164	)
165	round = builder.module.declare_intrinsic("llvm.round", [return_type])	1✔
166	src = builder.call(round, [src])	1✔
167	return src	1✔
168
169
170	def _is_fraction(builder, src, src_type):	1✔
171	if isinstance(src_type, Float):	1✔
172	return_type = (	1✔
173	llvmirtypes.DoubleType()
174	if src_type.bitwidth == 64
175	else (
176	llvmirtypes.FloatType()
177	if src_type.bitwidth == 32
178	else llvmirtypes.HalfType()
179	)
180	)
181	llvm_fabs = builder.module.declare_intrinsic("llvm.fabs", [return_type])	1✔
182	src_abs = builder.call(llvm_fabs, [src])	1✔
183	ret = True	1✔
184	is_lto = builder.fcmp_ordered(">=", src_abs, src.type(1.0))	1✔
185	with builder.if_then(is_lto):	1✔
186	ret = False	1✔
187	return ret	1✔
188
189
190	def _normalize(builder, src, src_type, dest_type, rounding=False):	1✔
191	dest_llvm_type = _get_llvm_type(dest_type)	1✔
192	if isinstance(src_type, Integer) and isinstance(dest_type, Integer):	1✔
193	if src_type.bitwidth < dest_type.bitwidth:	1!
NEW 194	return builder.zext(src, dest_llvm_type)	×
195	elif src_type.bitwidth > dest_type.bitwidth:	1✔
196	return builder.trunc(src, dest_llvm_type)	1✔
197	else:
198	return src	1✔
199	elif isinstance(src_type, Integer) and isinstance(dest_type, Float):	1✔
200	if src_type.signed:	1!
201	return builder.sitofp(src, dest_llvm_type)	1✔
202	else:
NEW 203	return builder.uitofp(src, dest_llvm_type)	×
204	elif isinstance(src_type, Float) and isinstance(dest_type, Integer):	1✔
205	if rounding:	1✔
206	src = _round(builder, src, src_type)	1✔
207	if dest_type.signed:	1!
208	return builder.fptosi(src, dest_llvm_type)	1✔
209	else:
NEW 210	return builder.fptoui(src, dest_llvm_type)	×
211	elif isinstance(src_type, Float) and isinstance(dest_type, Float):	1!
212	if src_type.bitwidth < dest_type.bitwidth:	1!
NEW 213	return builder.fpext(src, dest_llvm_type)	×
214	elif src_type.bitwidth > dest_type.bitwidth:	1✔
215	return builder.fptrunc(src, dest_llvm_type)	1✔
216	else:
217	return src	1✔
218	else:
NEW 219	msg = (	×
220	"dpnp_iface.array_sequence_ops._normalize(): "
221	+ f"{src}[{src_type}] is neither a "
222	+ "'numba.core.types.scalars.Float' "
223	+ "nor an 'numba.core.types.scalars.Integer'."
224	)
NEW 225	raise errors.NumbaTypeError(msg)	×
226
227
228	def _compute_array_length_ir(	1✔
229	builder,
230	start_ir,
231	stop_ir,
232	step_ir,
233	start_arg_type,
234	stop_arg_type,
235	step_arg_type,
236	):
237	lb = _normalize(builder, start_ir, start_arg_type, types.float64)	1✔
238	ub = _normalize(builder, stop_ir, stop_arg_type, types.float64)	1✔
239	n = _normalize(builder, step_ir, step_arg_type, types.float64)	1✔
240
241	llvm_ceil = builder.module.declare_intrinsic(	1✔
242	"llvm.ceil", [llvmirtypes.DoubleType()]
243	)
244
245	array_length_ir = builder.fptosi(	1✔
246	builder.call(
247	llvm_ceil,
248	[builder.fdiv(builder.fsub(ub, lb), n)],
249	),
250	llvmir.IntType(64),
251	)
252
253	return array_length_ir	1✔
254
255
256	@intrinsic	1✔
257	def impl_dpnp_arange(	1✔
258	ty_context,
259	ty_start,
260	ty_stop,
261	ty_step,
262	ty_dtype,
263	ty_device,
264	ty_usm_type,
265	ty_sycl_queue,
266	ty_ret_ty,
267	):
268	ty_retty_ = ty_ret_ty.instance_type	1✔
269	signature = ty_retty_(	1✔
270	ty_start,
271	ty_stop,
272	ty_step,
273	ty_dtype,
274	ty_device,
275	ty_usm_type,
276	ty_sycl_queue,
277	ty_ret_ty,
278	)
279
280	sycl_queue_arg_pos = -2	1✔
281
282	def codegen(context, builder, sig, args):	1✔
283	# Rename variables for easy coding
284	start_ir, stop_ir, step_ir, queue_ir = (	1✔
285	args[0],
286	args[1],
287	args[2],
288	args[sycl_queue_arg_pos],
289	)
290	(	1✔
291	start_arg_type,
292	stop_arg_type,
293	step_arg_type,
294	dtype_arg_type,
295	queue_arg_type,
296	) = (
297	sig.args[0],
298	sig.args[1],
299	sig.args[2],
300	sig.args[3],
301	sig.args[sycl_queue_arg_pos],
302	)
303
304	# Get SYCL Queue ref
305	sycl_queue_arg = _ArgTyAndValue(queue_arg_type, queue_ir)	1✔
306	qref_payload: _QueueRefPayload = _get_queue_ref(	1✔
307	context=context,
308	builder=builder,
309	returned_sycl_queue_ty=sig.return_type.queue,
310	sycl_queue_arg=sycl_queue_arg,
311	)
312
313	# Sanity check:
314	# if stop is pointing to a null
315	# start <- 0
316	# stop <- 1
317	# if step is pointing to a null
318	# step <- 1
319	if isinstance(stop_arg_type, NoneType):	1✔
320	start_ir = context.get_constant(start_arg_type, 0)	1✔
321	stop_ir = context.get_constant(start_arg_type, 1)	1✔
322	stop_arg_type = start_arg_type	1✔
323	if isinstance(step_arg_type, NoneType):	1✔
324	step_ir = context.get_constant(start_arg_type, 1)	1✔
325	step_arg_type = start_arg_type	1✔
326
327	# Keep note if either start or stop is in (-1.0, 0.0] or [0.0, 1.0)
328	round_step = not (	1✔
329	_is_fraction(builder, start_ir, start_arg_type)
330	and _is_fraction(builder, stop_ir, stop_arg_type)
331	)
332
333	# Allocate an empty array
334	len = _compute_array_length_ir(	1✔
335	builder,
336	start_ir,
337	stop_ir,
338	step_ir,
339	start_arg_type,
340	stop_arg_type,
341	step_arg_type,
342	)
343	ary = _empty_nd_impl(	1✔
344	context, builder, sig.return_type, [len], qref_payload.queue_ref
345	)
346	# Convert into void*
347	arrystruct_vptr = builder.bitcast(ary._getpointer(), cgutils.voidptr_t)	1✔
348
349	# Extend or truncate input values w.r.t. destination array type
350	start_ir = _normalize(	1✔
351	builder, start_ir, start_arg_type, dtype_arg_type.dtype
352	)
353	stop_ir = _normalize(	1✔
354	builder, stop_ir, stop_arg_type, dtype_arg_type.dtype
355	)
356	step_ir = _normalize(	1✔
357	builder,
358	step_ir,
359	step_arg_type,
360	dtype_arg_type.dtype,
361	rounding=round_step,
362	)
363
364	# After normalization, their arg_types will change
365	start_arg_type = dtype_arg_type.dtype	1✔
366	stop_arg_type = dtype_arg_type.dtype	1✔
367	step_arg_type = dtype_arg_type.dtype	1✔
368
369	# Construct function parameters
370	with builder.goto_entry_block():	1✔
371	start_ptr = cgutils.alloca_once(builder, start_ir.type)	1✔
372	step_ptr = cgutils.alloca_once(builder, step_ir.type)	1✔
373	builder.store(start_ir, start_ptr)	1✔
374	builder.store(step_ir, step_ptr)	1✔
375	start_vptr = builder.bitcast(start_ptr, cgutils.voidptr_t)	1✔
376	step_vptr = builder.bitcast(step_ptr, cgutils.voidptr_t)	1✔
377	ndim = context.get_constant(types.intp, 1)	1✔
378	is_c_contguous = context.get_constant(types.int8, 1)	1✔
379	typeid_index = _get_dst_typeid(dtype_arg_type.dtype)	1✔
380	dst_typeid = context.get_constant(types.intp, typeid_index)	1✔
381
382	# Function signature
383	fnty = llvmir.FunctionType(	1✔
384	utils.LLVMTypes.int64_ptr_t,
385	[
386	cgutils.voidptr_t,
387	cgutils.voidptr_t,
388	cgutils.voidptr_t,
389	_get_llvm_type(types.intp),
390	_get_llvm_type(types.int8),
391	_get_llvm_type(types.intp),
392	cgutils.voidptr_t,
393	],
394	)
395
396	# Kernel call
397	fn = cgutils.get_or_insert_function(	1✔
398	builder.module,
399	fnty,
400	"NUMBA_DPEX_SYCL_KERNEL_populate_arystruct_sequence",
401	)
402	builder.call(	1✔
403	fn,
404	[
405	start_vptr,
406	step_vptr,
407	arrystruct_vptr,
408	ndim,
409	is_c_contguous,
410	dst_typeid,
411	qref_payload.queue_ref,
412	],
413	)
414
415	return ary._getvalue()	1✔
416
417	return signature, codegen	1✔
418
419
420	@overload(dpnp.arange, prefer_literal=True)	1✔
421	def ol_dpnp_arange(	1✔
422	start,
423	stop=None,
424	step=1,
425	dtype=None,
426	device=None,
427	usm_type="device",
428	sycl_queue=None,
429	):
430	if isinstance(start, Complex) or (	1!
431	not is_nonelike(dtype) and isinstance(dtype.dtype, Complex)
432	):
NEW 433	raise errors.NumbaNotImplementedError(	×
434	"Complex type is not supported yet."
435	)
436	if isinstance(start, Boolean) or (	1!
437	not is_nonelike(dtype) and isinstance(dtype.dtype, Boolean)
438	):
NEW 439	raise errors.NumbaTypeError(	×
440	"Boolean is not supported by dpnp.arange()."
441	)
442
443	if is_nonelike(stop):	1✔
444	start = 0 if type(start) == int or isinstance(start, Integer) else 0.0	1✔
445	stop = 1 if type(start) == int or isinstance(start, Integer) else 1.0	1✔
446	if is_nonelike(step):	1✔
447	step = 1 if type(start) == int or isinstance(start, Integer) else 1.0	1✔
448
449	_dtype = (	1✔
450	_parse_dtype(dtype)
451	if not is_nonelike(dtype)
452	else _parse_dtype_from_range(start, stop, step)
453	)
454	_device = _parse_device_filter_string(device) if device else None	1✔
455	_usm_type = _parse_usm_type(usm_type) if usm_type else "device"	1✔
456
457	ret_ty = DpnpNdArray(	1✔
458	ndim=1,
459	layout="C",
460	dtype=_dtype,
461	usm_type=_usm_type,
462	device=_device,
463	queue=sycl_queue,
464	)
465
466	if ret_ty:	1!
467
468	def impl(	1✔
469	start,
470	stop=None,
471	step=1,
472	dtype=None,
473	device=None,
474	usm_type="device",
475	sycl_queue=None,
476	):
NEW 477	return impl_dpnp_arange(	×
478	start,
479	stop,
480	step,
481	_dtype,
482	_device,
483	_usm_type,
484	sycl_queue,
485	ret_ty,
486	)
487
488	return impl	1✔
489	else:
NEW 490	raise errors.TypingError(	×
491	"Cannot parse input types to "
492	+ f"function dpnp.arange({start}, {stop}, {step}, ...)."
493	)

IntelPython / numba-dpex / 6794434213

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous