Development milestone 0.14.6dev4

.github/workflows/os-llvm-sycl-build.yml

@@ -7,7 +7,7 @@ on:
 jobs:
   install-compiler:
     name: Build with nightly build of DPC++ toolchain
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
 
     env:
       DOWNLOAD_URL_PREFIX: https://github.com/intel/llvm/releases/download
@@ -38,16 +38,17 @@ jobs:
 
       - name: Download and install nightly and components
         env:
-          USE_LATEST_SYCLOS: 0
+          ARTIFACT_NAME: sycl_linux
+          USE_LATEST_SYCLOS: 1
         shell: bash -l {0}
         run: |
           cd /home/runner/work
           mkdir -p sycl_bundle
           cd sycl_bundle
           if [[ "${USE_LATEST_SYCLOS:-0}" -eq "1" ]]; then
-              # get list of shas and tags from remote, filter sycl-nightly tags and reverse order
+              # get list of shas and tags from remote, filter nightly tags and reverse order
               export LLVM_TAGS=$(git -c 'versionsort.suffix=-' ls-remote --tags --sort='v:refname' https://github.com/intel/llvm.git | \
-                          grep sycl-nightly | awk '{a[i++]=$0} END {for (j=i-1; j>=0;) print a[j--] }')
+                          grep 'refs/tags/nightly-' | awk '{a[i++]=$0} END {for (j=i-1; j>=0;) print a[j--] }')
               # initialize
               unset DEPLOY_NIGHTLY_TAG
               unset DEPLOY_NIGHTLY_TAG_SHA
@@ -57,7 +58,7 @@ jobs:
                   export NEXT_LLVM_TAG_SHA=$(echo ${NEXT_LLVM_TAG} | awk '{print $1}')
                   export NEXT_NIGHTLY_TAG=$(python3 -c "import sys, urllib.parse as ul; print (ul.quote_plus(sys.argv[1]))" \
                                               $(echo ${NEXT_LLVM_TAG} | awk '{gsub(/^refs\/tags\//, "", $2)} {print $2}'))
-                  if [[ `wget -S --spider ${DOWNLOAD_URL_PREFIX}/${NEXT_NIGHTLY_TAG}/dpcpp-compiler.tar.gz  2>&1 | grep 'HTTP/1.1 200 OK'` ]];
+                  if [[ `wget -S --spider ${DOWNLOAD_URL_PREFIX}/${NEXT_NIGHTLY_TAG}/${ARTIFACT_NAME}.tar.gz  2>&1 | grep 'HTTP/1.1 200 OK'` ]];
                   then
                       export DEPLOY_NIGHTLY_TAG=${NEXT_NIGHTLY_TAG}
                       export DEPLOY_LLVM_TAG_SHA=${NEXT_LLVM_TAG_SHA}
@@ -77,21 +78,20 @@ jobs:
           if [[ -f bundle_id.txt && ( "$(cat bundle_id.txt)" == "${DEPLOY_LLVM_TAG_SHA}" ) ]]; then
               echo "Using cached download of ${DEPLOY_LLVM_TAG_SHA}"
           else
-              rm -rf dpcpp-compiler.tar.gz
-              wget ${DOWNLOAD_URL_PREFIX}/${DEPLOY_NIGHTLY_TAG}/dpcpp-compiler.tar.gz && echo ${DEPLOY_LLVM_TAG_SHA} > bundle_id.txt || rm -rf bundle_id.txt
+              rm -rf ${ARTIFACT_NAME}.tar.gz
+              wget ${DOWNLOAD_URL_PREFIX}/${DEPLOY_NIGHTLY_TAG}/${ARTIFACT_NAME}.tar.gz && echo ${DEPLOY_LLVM_TAG_SHA} > bundle_id.txt || rm -rf bundle_id.txt
               [ -f ${OCLCPUEXP_FN} ] || wget ${DOWNLOAD_URL_PREFIX}/${DRIVER_PATH}/${OCLCPUEXP_FN} || rm -rf bundle_id.txt
               [ -f ${FPGAEMU_FN} ] || wget ${DOWNLOAD_URL_PREFIX}/${DRIVER_PATH}/${FPGAEMU_FN} || rm -rf bundle_id.txt
               [ -f ${TBB_FN} ] || wget ${TBB_URL}/${TBB_FN} || rm -rf bundle_id.txt
               rm -rf dpcpp_compiler
-              tar xf dpcpp-compiler.tar.gz
+              mkdir -p dpcpp_compiler
+              tar xf ${ARTIFACT_NAME}.tar.gz -C dpcpp_compiler
               mkdir -p oclcpuexp
               mkdir -p fpgaemu
               [ -d oclcpuexp/x64 ] || tar xf ${OCLCPUEXP_FN} -C oclcpuexp
               [ -d fpgaemu/x64 ] || tar xf ${FPGAEMU_FN} -C fpgaemu
               [ -d ${TBB_INSTALL_DIR}/lib ] || tar xf ${TBB_FN}
-              mkdir -p dpcpp_compiler/lib
-              mkdir -p dpcpp_compiler/lib/oclfpga
-              touch dpcpp_compiler/lib/oclfpga/fpgavars.sh
+              cp oclcpuexp/x64/libOpenCL.so* dpcpp_compiler/lib/
           fi
 
       - name: Install system components
@@ -121,7 +121,8 @@ jobs:
           cat << 'EOF' > set_allvars.sh
           #!/usr/bin/bash
           export SYCL_BUNDLE_FOLDER=/home/runner/work/sycl_bundle
-          source ${SYCL_BUNDLE_FOLDER}/dpcpp_compiler/startup.sh
+          export PATH=${SYCL_BUNDLE_FOLDER}/dpcpp_compiler/bin:${PATH}
+          export LD_LIBRARY_PATH=${SYCL_BUNDLE_FOLDER}/dpcpp_compiler/lib:${LD_LIBRARY_PATH}
           export LD_LIBRARY_PATH=${SYCL_BUNDLE_FOLDER}/oclcpuexp/x64:${LD_LIBRARY_PATH}
           export LD_LIBRARY_PATH=${SYCL_BUNDLE_FOLDER}/fpgaemu/x64:${LD_LIBRARY_PATH}
           export LD_LIBRARY_PATH=${SYCL_BUNDLE_FOLDER}/${TBB_INSTALL_DIR}/lib/intel64/gcc4.8:${LD_LIBRARY_PATH}

README.md

@@ -43,8 +43,8 @@ to program on XPUs.
 
 # Installing
 
-You can install the library with [conda](https://anaconda.org/intel/dpctl) and
-[pip](https://pypi.org/project/dpctl/). It is also available in the [Intel(R)
+You can install the library using [conda](https://anaconda.org/intel/dpctl) or
+[pip](https://pypi.org/project/dpctl/) package managers. It is also available in the [Intel(R)
 Distribution for
 Python](https://www.intel.com/content/www/us/en/developer/tools/oneapi/distribution-for-python.html)
 (IDP).
@@ -70,12 +70,13 @@ cloud, use the following command:
 conda install dpctl -c intel
 ```
 
-## PyPi
+## Pip
 
-To install `dpctl` from PyPi, run the following command:
+The `dpctl` can be installed using `pip` obtaining wheel packages either from PyPi or from Intel(R) channel on Anaconda.
+To install `dpctl` wheel package from Intel(R) channel on Anaconda, run the following command:
 
 ```bash
-pip3 install dpctl
+python -m pip install --index-url https://pypi.anaconda.org/intel/simple dpctl
 ```
 
 Installing the bleeding edge

conda-recipe/meta.yaml

@@ -33,6 +33,8 @@ requirements:
 
 test:
     requires:
+        - {{ compiler('c') }}
+        - {{ compiler('cxx') }}
         - cython
         - setuptools
         - pytest

dpctl/tensor/CMakeLists.txt

@@ -58,10 +58,15 @@ set_source_files_properties(
   ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/linear_sequences.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/elementwise_functions.cpp
   PROPERTIES COMPILE_OPTIONS "${_clang_prefix}-fno-fast-math")
+if (UNIX)
+  set_source_files_properties(
+    ${CMAKE_CURRENT_SOURCE_DIR}/libtensor/source/elementwise_functions.cpp
+    PROPERTIES COMPILE_DEFINITIONS "USE_STD_ABS_FOR_COMPLEX_TYPES;USE_STD_SQRT_FOR_COMPLEX_TYPES")
+endif()
 target_compile_options(${python_module_name} PRIVATE -fno-sycl-id-queries-fit-in-int)
 target_link_options(${python_module_name} PRIVATE -fsycl-device-code-split=per_kernel)
 if(UNIX)
-    # this option is support on Linux only
+    # this option is supported on Linux only
     target_link_options(${python_module_name} PRIVATE -fsycl-link-huge-device-code)
 endif()
 target_include_directories(${python_module_name}

dpctl/tensor/__init__.py

@@ -158,6 +158,7 @@
     trunc,
 )
 from ._reduction import sum
+from ._testing import allclose
 
 __all__ = [
     "Device",
@@ -301,4 +302,5 @@
     "tan",
     "tanh",
     "trunc",
+    "allclose",
 ]

dpctl/tensor/_copy_utils.py

@@ -24,7 +24,7 @@
 import dpctl.tensor as dpt
 import dpctl.tensor._tensor_impl as ti
 import dpctl.utils
-from dpctl.tensor._ctors import _get_dtype
+from dpctl.tensor._data_types import _get_dtype
 from dpctl.tensor._device import normalize_queue_device
 
 __doc__ = (
@@ -351,14 +351,16 @@ def _empty_like_orderK(X, dt, usm_type=None, dev=None):
         )
     st = list(X.strides)
     perm = sorted(
-        range(X.ndim), key=lambda d: builtins.abs(st[d]), reverse=True
+        range(X.ndim),
+        key=lambda d: builtins.abs(st[d]) if X.shape[d] > 1 else 0,
+        reverse=True,
     )
     inv_perm = sorted(range(X.ndim), key=lambda i: perm[i])
-    st_sorted = [st[i] for i in perm]
     sh = X.shape
     sh_sorted = tuple(sh[i] for i in perm)
     R = dpt.empty(sh_sorted, dtype=dt, usm_type=usm_type, device=dev, order="C")
-    if min(st_sorted) < 0:
+    if min(st) < 0:
+        st_sorted = [st[i] for i in perm]
         sl = tuple(
             slice(None, None, -1)
             if st_sorted[i] < 0
@@ -395,9 +397,14 @@ def _empty_like_pair_orderK(X1, X2, dt, res_shape, usm_type, dev):
     max_ndim = max(nd1, nd2)
     st1 += [0] * (max_ndim - len(st1))
     st2 += [0] * (max_ndim - len(st2))
+    sh1 = list(X1.shape) + [0] * (max_ndim - nd1)
+    sh2 = list(X2.shape) + [0] * (max_ndim - nd2)
     perm = sorted(
         range(max_ndim),
-        key=lambda d: (builtins.abs(st1[d]), builtins.abs(st2[d])),
+        key=lambda d: (
+            builtins.abs(st1[d]) if sh1[d] > 1 else 0,
+            builtins.abs(st2[d]) if sh2[d] > 1 else 0,
+        ),
         reverse=True,
     )
     inv_perm = sorted(range(max_ndim), key=lambda i: perm[i])
@@ -417,6 +424,74 @@ def _empty_like_pair_orderK(X1, X2, dt, res_shape, usm_type, dev):
     return dpt.permute_dims(R, inv_perm)
 
 
+def _empty_like_triple_orderK(X1, X2, X3, dt, res_shape, usm_type, dev):
+    if not isinstance(X1, dpt.usm_ndarray):
+        raise TypeError(f"Expected usm_ndarray, got {type(X1)}")
+    if not isinstance(X2, dpt.usm_ndarray):
+        raise TypeError(f"Expected usm_ndarray, got {type(X2)}")
+    if not isinstance(X3, dpt.usm_ndarray):
+        raise TypeError(f"Expected usm_ndarray, got {type(X3)}")
+    nd1 = X1.ndim
+    nd2 = X2.ndim
+    nd3 = X3.ndim
+    if X1.shape == res_shape and X2.shape == res_shape and len(res_shape) > nd3:
+        return _empty_like_pair_orderK(X1, X2, dt, res_shape, usm_type, dev)
+    elif (
+        X2.shape == res_shape and X3.shape == res_shape and len(res_shape) > nd1
+    ):
+        return _empty_like_pair_orderK(X2, X3, dt, res_shape, usm_type, dev)
+    elif (
+        X1.shape == res_shape and X3.shape == res_shape and len(res_shape) > nd2
+    ):
+        return _empty_like_pair_orderK(X1, X3, dt, res_shape, usm_type, dev)
+    fl1 = X1.flags
+    fl2 = X2.flags
+    fl3 = X3.flags
+    if fl1["C"] or fl2["C"] or fl3["C"]:
+        return dpt.empty(
+            res_shape, dtype=dt, usm_type=usm_type, device=dev, order="C"
+        )
+    if fl1["F"] and fl2["F"] and fl3["F"]:
+        return dpt.empty(
+            res_shape, dtype=dt, usm_type=usm_type, device=dev, order="F"
+        )
+    st1 = list(X1.strides)
+    st2 = list(X2.strides)
+    st3 = list(X3.strides)
+    max_ndim = max(nd1, nd2, nd3)
+    st1 += [0] * (max_ndim - len(st1))
+    st2 += [0] * (max_ndim - len(st2))
+    st3 += [0] * (max_ndim - len(st3))
+    sh1 = list(X1.shape) + [0] * (max_ndim - nd1)
+    sh2 = list(X2.shape) + [0] * (max_ndim - nd2)
+    sh3 = list(X3.shape) + [0] * (max_ndim - nd3)
+    perm = sorted(
+        range(max_ndim),
+        key=lambda d: (
+            builtins.abs(st1[d]) if sh1[d] > 1 else 0,
+            builtins.abs(st2[d]) if sh2[d] > 1 else 0,
+            builtins.abs(st3[d]) if sh3[d] > 1 else 0,
+        ),
+        reverse=True,
+    )
+    inv_perm = sorted(range(max_ndim), key=lambda i: perm[i])
+    st1_sorted = [st1[i] for i in perm]
+    st2_sorted = [st2[i] for i in perm]
+    st3_sorted = [st3[i] for i in perm]
+    sh = res_shape
+    sh_sorted = tuple(sh[i] for i in perm)
+    R = dpt.empty(sh_sorted, dtype=dt, usm_type=usm_type, device=dev, order="C")
+    if max(min(st1_sorted), min(st2_sorted), min(st3_sorted)) < 0:
+        sl = tuple(
+            slice(None, None, -1)
+            if (st1_sorted[i] < 0 and st2_sorted[i] < 0 and st3_sorted[i] < 0)
+            else slice(None, None, None)
+            for i in range(nd1)
+        )
+        R = R[sl]
+    return dpt.permute_dims(R, inv_perm)
+
+
 def copy(usm_ary, order="K"):
     """copy(ary, order="K")
 

dpctl/tensor/_ctors.py

@@ -23,6 +23,8 @@
 import dpctl.tensor as dpt
 import dpctl.tensor._tensor_impl as ti
 import dpctl.utils
+from dpctl.tensor._copy_utils import _empty_like_orderK
+from dpctl.tensor._data_types import _get_dtype
 from dpctl.tensor._device import normalize_queue_device
 from dpctl.tensor._usmarray import _is_object_with_buffer_protocol
 
@@ -32,24 +34,6 @@
 _host_set = frozenset([None])
 
 
-def _get_dtype(dtype, sycl_obj, ref_type=None):
-    if dtype is None:
-        if ref_type in [None, float] or np.issubdtype(ref_type, np.floating):
-            dtype = ti.default_device_fp_type(sycl_obj)
-            return dpt.dtype(dtype)
-        if ref_type in [bool, np.bool_]:
-            dtype = ti.default_device_bool_type(sycl_obj)
-            return dpt.dtype(dtype)
-        if ref_type is int or np.issubdtype(ref_type, np.integer):
-            dtype = ti.default_device_int_type(sycl_obj)
-            return dpt.dtype(dtype)
-        if ref_type is complex or np.issubdtype(ref_type, np.complexfloating):
-            dtype = ti.default_device_complex_type(sycl_obj)
-            return dpt.dtype(dtype)
-        raise TypeError(f"Reference type {ref_type} not recognized.")
-    return dpt.dtype(dtype)
-
-
 def _array_info_dispatch(obj):
     if isinstance(obj, dpt.usm_ndarray):
         return obj.shape, obj.dtype, frozenset([obj.sycl_queue])
@@ -162,28 +146,7 @@ def _asarray_from_usm_ndarray(
         order = "C" if c_contig else "F"
     if order == "K":
         _ensure_native_dtype_device_support(dtype, copy_q.sycl_device)
-        # new USM allocation
-        res = dpt.usm_ndarray(
-            usm_ndary.shape,
-            dtype=dtype,
-            buffer=usm_type,
-            order="C",
-            buffer_ctor_kwargs={"queue": copy_q},
-        )
-        original_strides = usm_ndary.strides
-        ind = sorted(
-            range(usm_ndary.ndim),
-            key=lambda i: abs(original_strides[i]),
-            reverse=True,
-        )
-        new_strides = tuple(res.strides[ind[i]] for i in ind)
-        # reuse previously made USM allocation
-        res = dpt.usm_ndarray(
-            usm_ndary.shape,
-            dtype=res.dtype,
-            buffer=res.usm_data,
-            strides=new_strides,
-        )
+        res = _empty_like_orderK(usm_ndary, dtype, usm_type, copy_q)
     else:
         _ensure_native_dtype_device_support(dtype, copy_q.sycl_device)
         res = dpt.usm_ndarray(

dpctl/tensor/_data_types.py

@@ -14,7 +14,25 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from numpy import bool_ as np_bool_
+from numpy import complexfloating as np_complexfloating
 from numpy import dtype
+from numpy import floating as np_floating
+from numpy import integer as np_integer
+from numpy import issubdtype as np_issubdtype
+
+from dpctl.tensor._tensor_impl import (
+    default_device_bool_type as ti_default_device_bool_type,
+)
+from dpctl.tensor._tensor_impl import (
+    default_device_complex_type as ti_default_device_complex_type,
+)
+from dpctl.tensor._tensor_impl import (
+    default_device_fp_type as ti_default_device_fp_type,
+)
+from dpctl.tensor._tensor_impl import (
+    default_device_int_type as ti_default_device_int_type,
+)
 
 bool = dtype("bool")
 int8 = dtype("int8")
@@ -74,6 +92,32 @@ def isdtype(dtype_, kind):
         raise TypeError(f"Unsupported data type kind: {kind}")
 
 
+def _get_dtype(inp_dt, sycl_obj, ref_type=None):
+    """
+    Type inference utility to construct data type
+    object with defaults based on reference type.
+
+    _get_dtype is used by dpctl.tensor.asarray
+    to infer data type of the output array from the
+    input sequence.
+    """
+    if inp_dt is None:
+        if ref_type in [None, float] or np_issubdtype(ref_type, np_floating):
+            fp_dt = ti_default_device_fp_type(sycl_obj)
+            return dtype(fp_dt)
+        if ref_type in [bool, np_bool_]:
+            bool_dt = ti_default_device_bool_type(sycl_obj)
+            return dtype(bool_dt)
+        if ref_type is int or np_issubdtype(ref_type, np_integer):
+            int_dt = ti_default_device_int_type(sycl_obj)
+            return dtype(int_dt)
+        if ref_type is complex or np_issubdtype(ref_type, np_complexfloating):
+            cfp_dt = ti_default_device_complex_type(sycl_obj)
+            return dtype(cfp_dt)
+        raise TypeError(f"Reference type {ref_type} not recognized.")
+    return dtype(inp_dt)
+
+
 __all__ = [
     "dtype",
     "isdtype",