diff --git a/.flake8 b/.flake8 index 1453996659..4d0b83f2e0 100644 --- a/.flake8 +++ b/.flake8 @@ -22,7 +22,7 @@ per-file-ignores = dpctl/_sycl_queue.pyx: E999, E225, E226, E227 dpctl/_sycl_queue_manager.pyx: E999, E225 dpctl/memory/_memory.pyx: E999, E225, E226, E227 - dpctl/program/_program.pyx: E999, E225, E226, E227 + dpctl/compiler/_compiler.pyx: E999, E225, E226, E227 dpctl/tests/_cython_api.pyx: E999, E225, E227, E402 dpctl/utils/_onetrace_context.py: E501, W505 examples/cython/sycl_buffer/syclbuffer/_syclbuffer.pyx: E999, E225, E402 diff --git a/docs/doc_sources/api_reference/dpctl/compiler.rst b/docs/doc_sources/api_reference/dpctl/compiler.rst new file mode 100644 index 0000000000..c887ecf562 --- /dev/null +++ b/docs/doc_sources/api_reference/dpctl/compiler.rst @@ -0,0 +1,38 @@ +.. _dpctl_compiler_pyapi: + +:py:mod:`dpctl.compiler` +======================== + +:py:mod:`dpctl.compiler` provides a way to create a SYCL kernel +from either an OpenCL* program source code represented as a string +or a SPIR-V binary file. + +It implements creation of interoperability +``sycl::kernel_bundle`` (a collection of kernels), +as well as creation of individual ``sycl::kernel``, suitable for submission for +execution via :py:meth:`dpctl.SyclQueue.submit`. + +.. py:module:: dpctl.compiler + +.. currentmodule:: dpctl.compiler + +.. autosummary:: + :toctree: generated + :nosignatures: + + create_kernel_bundle_from_source + create_kernel_bundle_from_spirv + +.. autosummary:: + :toctree: generated + :nosignatures: + + SyclKernelBundle + SyclKernel + SpecializationConstant + +.. autosummary:: + :toctree: generated + :nosignatures: + + SyclKernelBundleCompilationError diff --git a/docs/doc_sources/api_reference/dpctl/index.rst b/docs/doc_sources/api_reference/dpctl/index.rst index 87fdfb16b2..52dc55219a 100644 --- a/docs/doc_sources/api_reference/dpctl/index.rst +++ b/docs/doc_sources/api_reference/dpctl/index.rst @@ -14,8 +14,10 @@ * - :py:mod:`dpctl.memory` - Unified Shared Memory operations - * - :py:mod:`dpctl.program` + * - :py:mod:`dpctl.compiler` - Support for working with SYCL kernels + * - :py:mod:`dpctl.program` + - (deprecated, use :py:mod:`dpctl.compiler`) * - :py:mod:`dpctl.utils` - A collection of utility functions diff --git a/docs/doc_sources/api_reference/dpctl/program.rst b/docs/doc_sources/api_reference/dpctl/program.rst index aee4b574a8..619947fd6c 100644 --- a/docs/doc_sources/api_reference/dpctl/program.rst +++ b/docs/doc_sources/api_reference/dpctl/program.rst @@ -1,7 +1,10 @@ .. _dpctl_program_pyapi: -:py:mod:`dpctl.program` -======================= +:py:mod:`dpctl.program` (deprecated) +===================================== + +.. deprecated:: + :py:mod:`dpctl.program` is deprecated. Use :py:mod:`dpctl.compiler` instead. :py:mod:`dpctl.program` provides a way to create a SYCL kernel from either an OpenCL* program source code represented as a string @@ -20,20 +23,8 @@ execution via :py:meth:`dpctl.SyclQueue.submit`. :toctree: generated :nosignatures: - create_kernel_bundle_from_source - create_kernel_bundle_from_spirv create_program_from_source create_program_from_spirv - -.. autosummary:: - :toctree: generated - :nosignatures: - - SyclKernelBundle SyclKernel - -.. autosummary:: - :toctree: generated - :nosignatures: - - SyclKernelBundleCompilationError + SyclProgram + SyclProgramCompilationError diff --git a/docs/doc_sources/api_reference/index.rst b/docs/doc_sources/api_reference/index.rst index 8e301febb6..fbe3b1da63 100644 --- a/docs/doc_sources/api_reference/index.rst +++ b/docs/doc_sources/api_reference/index.rst @@ -9,7 +9,8 @@ The package ``dpctl`` provides * Python language bindings for the DPC++ runtime - :ref:`API objects ` in :py:mod:`dpctl` namespace - :ref:`API objects ` in :py:mod:`dpctl.memory` namespace - - :ref:`API objects ` in :py:mod:`dpctl.program` namespace + - :ref:`API objects ` in :py:mod:`dpctl.compiler` namespace + - :ref:`API objects ` in :py:mod:`dpctl.program` namespace (deprecated, use :py:mod:`dpctl.compiler`) - :ref:`API objects ` in :py:mod:`dpctl.utils` namespace * Python C API - :ref:`C API ` for working with Python classes defined in :mod:`dpctl` @@ -31,6 +32,7 @@ The package ``dpctl`` provides dpctl/index dpctl/memory + dpctl/compiler dpctl/program dpctl/utils libsyclinterface/index diff --git a/dpctl/CMakeLists.txt b/dpctl/CMakeLists.txt index a24c7443f9..a4378a03d0 100644 --- a/dpctl/CMakeLists.txt +++ b/dpctl/CMakeLists.txt @@ -203,6 +203,6 @@ build_dpctl_ext(${_trgt} ${_cy_file} "dpctl" SYCL) target_include_directories(${_trgt} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) target_link_libraries(DpctlCAPI INTERFACE ${_trgt}_headers) -add_subdirectory(program) +add_subdirectory(compiler) add_subdirectory(memory) add_subdirectory(utils) diff --git a/dpctl/__init__.py b/dpctl/__init__.py index 5e442a8fc4..b0860cd352 100644 --- a/dpctl/__init__.py +++ b/dpctl/__init__.py @@ -125,6 +125,7 @@ # add submodules __all__ += [ "memory", + "compiler", "program", "utils", ] diff --git a/dpctl/_sycl_queue.pxd b/dpctl/_sycl_queue.pxd index 9469415cb8..eb10df860a 100644 --- a/dpctl/_sycl_queue.pxd +++ b/dpctl/_sycl_queue.pxd @@ -32,7 +32,7 @@ from ._backend cimport ( from ._sycl_context cimport SyclContext from ._sycl_device cimport SyclDevice from ._sycl_event cimport SyclEvent -from .program._program cimport SyclKernel +from .compiler._compiler cimport SyclKernel cdef public api class _SyclQueue [ diff --git a/dpctl/_sycl_queue.pyx b/dpctl/_sycl_queue.pyx index a9d0a2c71c..eb6f8be8c4 100644 --- a/dpctl/_sycl_queue.pyx +++ b/dpctl/_sycl_queue.pyx @@ -383,7 +383,7 @@ kernel_arg_type = _kernel_arg_type() cdef class SyclKernelSubmitError(Exception): """ A ``SyclKernelSubmitError`` exception is raised when - the provided :class:`.program.SyclKernel` could not be + the provided :class:`.compiler.SyclKernel` could not be submitted to the :class:`.SyclQueue`. """ @@ -1178,10 +1178,10 @@ cdef class SyclQueue(_SyclQueue): list dEvents=None ): """ - Asynchronously submit :class:`dpctl.program.SyclKernel` for execution. + Asynchronously submit :class:`dpctl.compiler.SyclKernel` for execution. Args: - kernel (dpctl.program.SyclKernel): + kernel (dpctl.compiler.SyclKernel): SYCL kernel object args (List[object]): List of kernel arguments @@ -1339,10 +1339,10 @@ cdef class SyclQueue(_SyclQueue): list dEvents=None ): """ - Submit :class:`dpctl.program.SyclKernel` for execution. + Submit :class:`dpctl.compiler.SyclKernel` for execution. Args: - kernel (dpctl.program.SyclKernel): + kernel (dpctl.compiler.SyclKernel): SYCL kernel object args (List[object]): List of kernel arguments diff --git a/dpctl/apis/include/dpctl4pybind11.hpp b/dpctl/apis/include/dpctl4pybind11.hpp index b1c17e8e90..49b242d68d 100644 --- a/dpctl/apis/include/dpctl4pybind11.hpp +++ b/dpctl/apis/include/dpctl4pybind11.hpp @@ -227,7 +227,7 @@ class dpctl_capi this->Memory_GetNumBytes_ = Memory_GetNumBytes; this->Memory_Make_ = Memory_Make; - // dpctl.program API + // dpctl.compiler API this->SyclKernel_GetKernelRef_ = SyclKernel_GetKernelRef; this->SyclKernel_Make_ = SyclKernel_Make; this->SyclKernelBundle_GetKernelBundleRef_ = @@ -450,7 +450,7 @@ template <> struct type_caster }; /* This type caster associates ``sycl::kernel`` C++ class with - * :class:`dpctl.program.SyclKernel` for the purposes of generation of + * :class:`dpctl.compiler.SyclKernel` for the purposes of generation of * Python bindings by pybind11. */ template <> struct type_caster @@ -469,7 +469,7 @@ template <> struct type_caster } else { throw py::type_error("Input is of unexpected type, expected " - "dpctl.program.SyclKernel"); + "dpctl.compiler.SyclKernel"); } } @@ -482,12 +482,12 @@ template <> struct type_caster return handle(reinterpret_cast(tmp)); } - DPCTL_TYPE_CASTER(sycl::kernel, _("dpctl.program.SyclKernel")); + DPCTL_TYPE_CASTER(sycl::kernel, _("dpctl.compiler.SyclKernel")); }; /* This type caster associates * ``sycl::kernel_bundle`` C++ class with - * :class:`dpctl.program.SyclKernelBundle` for the purposes of generation of + * :class:`dpctl.compiler.SyclKernelBundle` for the purposes of generation of * Python bindings by pybind11. */ template <> @@ -511,7 +511,7 @@ struct type_caster> } else { throw py::type_error("Input is of unexpected type, expected " - "dpctl.program.SyclKernelBundle"); + "dpctl.compiler.SyclKernelBundle"); } } @@ -526,7 +526,7 @@ struct type_caster> } DPCTL_TYPE_CASTER(sycl::kernel_bundle, - _("dpctl.program.SyclKernelBundle")); + _("dpctl.compiler.SyclKernelBundle")); }; /* This type caster associates diff --git a/dpctl/apis/include/dpctl_capi.h b/dpctl/apis/include/dpctl_capi.h index 9cf245aef5..b32c3ecf79 100644 --- a/dpctl/apis/include/dpctl_capi.h +++ b/dpctl/apis/include/dpctl_capi.h @@ -45,8 +45,8 @@ #include "dpctl/_sycl_queue_api.h" #include "dpctl/memory/_memory.h" #include "dpctl/memory/_memory_api.h" -#include "dpctl/program/_program.h" -#include "dpctl/program/_program_api.h" +#include "dpctl/compiler/_compiler.h" +#include "dpctl/compiler/_compiler_api.h" // clang-format on @@ -66,6 +66,6 @@ static inline void import_dpctl(void) import_dpctl___sycl_event(); import_dpctl___sycl_queue(); import_dpctl__memory___memory(); - import_dpctl__program___program(); + import_dpctl__compiler___compiler(); return; } diff --git a/dpctl/program/CMakeLists.txt b/dpctl/compiler/CMakeLists.txt similarity index 72% rename from dpctl/program/CMakeLists.txt rename to dpctl/compiler/CMakeLists.txt index e55d5b0e08..da92df546d 100644 --- a/dpctl/program/CMakeLists.txt +++ b/dpctl/compiler/CMakeLists.txt @@ -1,7 +1,6 @@ - file(GLOB _cython_sources *.pyx) foreach(_cy_file ${_cython_sources}) get_filename_component(_trgt ${_cy_file} NAME_WLE) - build_dpctl_ext(${_trgt} ${_cy_file} "dpctl/program" RELATIVE_PATH "..") + build_dpctl_ext(${_trgt} ${_cy_file} "dpctl/compiler" RELATIVE_PATH "..") target_link_libraries(DpctlCAPI INTERFACE ${_trgt}_headers) endforeach() diff --git a/dpctl/compiler/__init__.pxd b/dpctl/compiler/__init__.pxd new file mode 100644 index 0000000000..b3d6afb379 --- /dev/null +++ b/dpctl/compiler/__init__.pxd @@ -0,0 +1,32 @@ +# Data Parallel Control (dpctl) +# +# Copyright 2020-2025 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# distutils: language = c++ +# cython: language_level=3 + +"""Declares the extension types and functions for the Cython API +implemented in dpctl.compiler._compiler.pyx. +""" + + +from dpctl.compiler._compiler cimport ( + SyclKernel, + SyclKernelBundle, + create_kernel_bundle_from_source, + create_kernel_bundle_from_spirv, + create_program_from_source, + create_program_from_spirv, +) diff --git a/dpctl/compiler/__init__.py b/dpctl/compiler/__init__.py new file mode 100644 index 0000000000..3c16395140 --- /dev/null +++ b/dpctl/compiler/__init__.py @@ -0,0 +1,45 @@ +# Data Parallel Control (dpctl) +# +# Copyright 2020-2025 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +**Data Parallel Control Compiler** provides a way to create a SYCL kernel +from either an OpenCL program represented as a string or a SPIR-V binary +file. + +""" + +from dpctl.compiler._compiler import ( + SpecializationConstant, + SyclKernel, + SyclKernelBundle, + SyclKernelBundleCompilationError, + create_kernel_bundle_from_source, + create_kernel_bundle_from_spirv, +) + +__all__ = [ + "create_kernel_bundle_from_source", + "create_kernel_bundle_from_spirv", + "SyclKernel", + "SyclKernelBundle", + "SyclKernelBundleCompilationError", + "SpecializationConstant", +] + +# add submodules +__all__ += [ + "utils", +] diff --git a/dpctl/program/_program.pxd b/dpctl/compiler/_compiler.pxd similarity index 92% rename from dpctl/program/_program.pxd rename to dpctl/compiler/_compiler.pxd index 41f781cecd..04e329f159 100644 --- a/dpctl/program/_program.pxd +++ b/dpctl/compiler/_compiler.pxd @@ -68,7 +68,3 @@ cpdef create_kernel_bundle_from_spirv ( unicode copts=*, list specializations=*, ) -cpdef create_program_from_source (SyclQueue q, unicode source, unicode copts=*) -cpdef create_program_from_spirv ( - SyclQueue q, const unsigned char[:] IL, unicode copts=* -) diff --git a/dpctl/program/_program.pyx b/dpctl/compiler/_compiler.pyx similarity index 92% rename from dpctl/program/_program.pyx rename to dpctl/compiler/_compiler.pyx index 166d46a3e3..5a69720a1e 100644 --- a/dpctl/program/_program.pyx +++ b/dpctl/compiler/_compiler.pyx @@ -39,8 +39,6 @@ from libc.stdint cimport uint32_t from libc.stdlib cimport free, malloc from libc.string cimport memcmp -import warnings - from dpctl._backend cimport ( # noqa: E211, E402; DPCTLKernel_Copy, DPCTLKernel_Delete, @@ -188,14 +186,14 @@ cdef class SyclKernel: cdef api DPCTLSyclKernelRef SyclKernel_GetKernelRef(SyclKernel ker): """ C-API function to access opaque kernel reference from - Python object of type :class:`dpctl.program.SyclKernel`. + Python object of type :class:`dpctl.compiler.SyclKernel`. """ return ker.get_kernel_ref() cdef api SyclKernel SyclKernel_Make(DPCTLSyclKernelRef KRef, const char *name): """ - C-API function to create :class:`dpctl.program.SyclKernel` + C-API function to create :class:`dpctl.compiler.SyclKernel` instance from opaque sycl kernel reference. """ cdef DPCTLSyclKernelRef copied_KRef = DPCTLKernel_Copy(KRef) @@ -254,14 +252,14 @@ cdef api DPCTLSyclKernelBundleRef SyclKernelBundle_GetKernelBundleRef( SyclKernelBundle kb ): """ C-API function to access opaque kernel bundle reference from - Python object of type :class:`dpctl.program.SyclKernelBundle`. + Python object of type :class:`dpctl.compiler.SyclKernelBundle`. """ return kb.get_kernel_bundle_ref() cdef api SyclKernelBundle SyclKernelBundle_Make(DPCTLSyclKernelBundleRef KBRef): """ - C-API function to create :class:`dpctl.program.SyclKernelBundle` + C-API function to create :class:`dpctl.compiler.SyclKernelBundle` instance from opaque ``sycl::kernel_bundle`` reference. """ @@ -274,7 +272,7 @@ cdef class SpecializationConstant: SpecializationConstant(spec_id, *args) Python class representing SYCL specialization constants that can be used - when creating a :class:`dpctl.program.SyclKernelBundle` from SPIR-V. + when creating a :class:`dpctl.compiler.SyclKernelBundle` from SPIR-V. There are multiple ways to create a :class:`.SpecializationConstant`: @@ -552,33 +550,3 @@ cpdef create_kernel_bundle_from_spirv( free(spconsts) return SyclKernelBundle._create(KBref) - - -cpdef create_program_from_source(SyclQueue q, str src, str copts=""): - """This function is a deprecated alias for - :func:`dpctl.program.create_kernel_bundle_from_source`. - New code should use :func:`dpctl.program.create_kernel_bundle_from_source`. - """ - warnings.warn( - "create_program_from_source is deprecated and will be removed in a " - "future release. Use create_kernel_bundle_from_source instead.", - DeprecationWarning, - stacklevel=2, - ) - return create_kernel_bundle_from_source(q, src, copts) - - -cpdef create_program_from_spirv( - SyclQueue q, const unsigned char[:] IL, str copts="" -): - """This function is a deprecated alias for - :func:`dpctl.program.create_kernel_bundle_from_spirv`. - New code should use :func:`dpctl.program.create_kernel_bundle_from_spirv`. - """ - warnings.warn( - "create_program_from_spirv is deprecated and will be removed in a " - "future release. Use create_kernel_bundle_from_spirv instead.", - DeprecationWarning, - stacklevel=2, - ) - return create_kernel_bundle_from_spirv(q, IL, copts) diff --git a/dpctl/program/utils/__init__.py b/dpctl/compiler/utils/__init__.py similarity index 84% rename from dpctl/program/utils/__init__.py rename to dpctl/compiler/utils/__init__.py index 474f154f95..1359230360 100644 --- a/dpctl/program/utils/__init__.py +++ b/dpctl/compiler/utils/__init__.py @@ -15,10 +15,10 @@ # limitations under the License. """ -A collection of utility functions for dpctl.program module. +A collection of utility functions for dpctl.compiler module. """ -from ._utils import parse_spirv_specializations +from dpctl.compiler.utils._utils import parse_spirv_specializations __all__ = [ "parse_spirv_specializations", diff --git a/dpctl/program/utils/_utils.py b/dpctl/compiler/utils/_utils.py similarity index 99% rename from dpctl/program/utils/_utils.py rename to dpctl/compiler/utils/_utils.py index 86df0855ad..94b64834c5 100644 --- a/dpctl/program/utils/_utils.py +++ b/dpctl/compiler/utils/_utils.py @@ -14,7 +14,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Implements various utilities for the dpctl.program module.""" +"""Implements various utilities for the dpctl.compiler module.""" from dataclasses import dataclass from enum import IntEnum diff --git a/dpctl/program/__init__.pxd b/dpctl/program/__init__.pxd index 4e734f18ed..462d2f6e36 100644 --- a/dpctl/program/__init__.pxd +++ b/dpctl/program/__init__.pxd @@ -17,9 +17,18 @@ # distutils: language = c++ # cython: language_level=3 -"""Declares the extension types and functions for the Cython API -implemented in dpctl.program._program.pyx. +""" +Declares the extension types and functions for the Cython API +implemented in dpctl.compiler._compiler.pyx (deprecated, use dpctl.compiler +instead). """ -from dpctl.program._program cimport * +from dpctl.compiler._compiler cimport ( + SyclKernel, + SyclKernelBundle, + create_kernel_bundle_from_source, + create_kernel_bundle_from_spirv, + create_program_from_source, + create_program_from_spirv, +) diff --git a/dpctl/program/__init__.py b/dpctl/program/__init__.py index e1e625ff7a..9ab03b969b 100644 --- a/dpctl/program/__init__.py +++ b/dpctl/program/__init__.py @@ -15,60 +15,58 @@ # limitations under the License. """ -**Data Parallel Control Program** provides a way to create a SYCL kernel -from either an OpenCL program represented as a string or a SPIR-V binary +**Data Parallel Control Program** (deprecated) provides a way to create a SYCL +kernel from either an OpenCL program represented as a string or a SPIR-V binary file. +.. deprecated:: + The dpctl.program module is deprecated. Use dpctl.compiler instead. + """ -from ._program import ( - SpecializationConstant, +import warnings + +from dpctl.compiler import ( SyclKernel, SyclKernelBundle, SyclKernelBundleCompilationError, - create_kernel_bundle_from_source, - create_kernel_bundle_from_spirv, +) +from dpctl.program._program import ( create_program_from_source, create_program_from_spirv, ) __all__ = [ - "create_kernel_bundle_from_source", - "create_kernel_bundle_from_spirv", "create_program_from_source", "create_program_from_spirv", "SyclKernel", - "SyclKernelBundle", - "SyclKernelBundleCompilationError", "SyclProgram", "SyclProgramCompilationError", - "SpecializationConstant", ] -# add submodules -__all__ += [ - "utils", -] + +warnings.warn( + "dpctl.program is deprecated and will be removed in a future release. " + "Use dpctl.compiler instead.", + DeprecationWarning, + stacklevel=2, +) def __getattr__(name): if name == "SyclProgram": - from warnings import warn - - warn( + warnings.warn( "dpctl.program.SyclProgram is deprecated and will be removed in a " - "future release. Use dpctl.program.SyclKernelBundle instead.", + "future release. Use dpctl.compiler.SyclKernelBundle instead.", DeprecationWarning, stacklevel=2, ) return SyclKernelBundle if name == "SyclProgramCompilationError": - from warnings import warn - - warn( + warnings.warn( "dpctl.program.SyclProgramCompilationError is deprecated and will " "be removed in a future release. Use " - "dpctl.program.SyclKernelBundleCompilationError instead.", + "dpctl.compiler.SyclKernelBundleCompilationError instead.", DeprecationWarning, stacklevel=2, ) diff --git a/dpctl/program/_program.py b/dpctl/program/_program.py new file mode 100644 index 0000000000..8d524ed1f5 --- /dev/null +++ b/dpctl/program/_program.py @@ -0,0 +1,60 @@ +# Data Parallel Control (dpctl) +# +# Copyright 2020-2025 Intel Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Deprecated wrapper functions for backward compatibility.""" + +import warnings + +from dpctl.compiler import ( + SyclKernel, + create_kernel_bundle_from_source, + create_kernel_bundle_from_spirv, +) + + +def create_program_from_source(q, src, copts=""): + """This function is a deprecated alias for + :func:`dpctl.compiler.create_kernel_bundle_from_source`. + New code should use :func:`dpctl.compiler.create_kernel_bundle_from_source`. + """ + warnings.warn( + "create_program_from_source is deprecated and will be removed in a " + "future release. Use create_kernel_bundle_from_source instead.", + DeprecationWarning, + stacklevel=2, + ) + return create_kernel_bundle_from_source(q, src, copts) + + +def create_program_from_spirv(q, IL, copts=""): + """This function is a deprecated alias for + :func:`dpctl.compiler.create_kernel_bundle_from_spirv`. + New code should use :func:`dpctl.compiler.create_kernel_bundle_from_spirv`. + """ + warnings.warn( + "create_program_from_spirv is deprecated and will be removed in a " + "future release. Use create_kernel_bundle_from_spirv instead.", + DeprecationWarning, + stacklevel=2, + ) + return create_kernel_bundle_from_spirv(q, IL, copts) + + +__all__ = [ + "create_program_from_source", + "create_program_from_spirv", + "SyclKernel", +] diff --git a/dpctl/tests/test_raw_kernel_arg.py b/dpctl/tests/test_raw_kernel_arg.py index 335f268144..a9d7543fe7 100644 --- a/dpctl/tests/test_raw_kernel_arg.py +++ b/dpctl/tests/test_raw_kernel_arg.py @@ -69,7 +69,7 @@ def launch_raw_arg_kernel(raw): spirv_file = get_spirv_abspath("raw-arg-kernel.spv") with open(spirv_file, "br") as spv: spv_bytes = spv.read() - kb = dpctl.program.create_kernel_bundle_from_spirv(q, spv_bytes) + kb = dpctl.compiler.create_kernel_bundle_from_spirv(q, spv_bytes) kernel = kb.get_sycl_kernel("__sycl_kernel_raw_arg_kernel") local_size = 16 global_size = local_size * 8 diff --git a/dpctl/tests/test_sycl_context.py b/dpctl/tests/test_sycl_context.py index 0cb222573b..1334c36b96 100644 --- a/dpctl/tests/test_sycl_context.py +++ b/dpctl/tests/test_sycl_context.py @@ -168,22 +168,22 @@ def test_context_multi_device(): assert type(repr(ctx)) is str q1 = dpctl.SyclQueue(ctx, d1) q2 = dpctl.SyclQueue(ctx, d2) - import dpctl.memory as dpmem + import dpctl.memory as dpm - shmem_1 = dpmem.MemoryUSMShared(256, queue=q1) - shmem_2 = dpmem.MemoryUSMDevice(256, queue=q2) + shmem_1 = dpm.MemoryUSMShared(256, queue=q1) + shmem_2 = dpm.MemoryUSMDevice(256, queue=q2) shmem_2.copy_from_device(shmem_1) # create context for single sub-device ctx1 = dpctl.SyclContext(d1) q1 = dpctl.SyclQueue(ctx1, d1) - shmem_1 = dpmem.MemoryUSMShared(256, queue=q1) + shmem_1 = dpm.MemoryUSMShared(256, queue=q1) cap = ctx1._get_capsule() cap2 = ctx1._get_capsule() del ctx1 del cap2 # exercise deleter of non-renamed capsule ctx2 = dpctl.SyclContext(cap) q2 = dpctl.SyclQueue(ctx2, d1) - shmem_2 = dpmem.MemoryUSMDevice(256, queue=q2) + shmem_2 = dpm.MemoryUSMDevice(256, queue=q2) shmem_2.copy_from_device(shmem_1) diff --git a/dpctl/tests/test_sycl_event.py b/dpctl/tests/test_sycl_event.py index f23f88988b..9ac359a646 100644 --- a/dpctl/tests/test_sycl_event.py +++ b/dpctl/tests/test_sycl_event.py @@ -20,8 +20,8 @@ import pytest import dpctl -import dpctl.memory as dpctl_mem -import dpctl.program as dpctl_prog +import dpctl.compiler as dpc +import dpctl.memory as dpm from dpctl import event_status_type as esty from .helper import create_invalid_capsule @@ -37,12 +37,12 @@ def produce_event(profiling=False): q = dpctl.SyclQueue("opencl:cpu", property="enable_profiling") else: q = dpctl.SyclQueue("opencl:cpu") - kb = dpctl_prog.create_kernel_bundle_from_source(q, oclSrc) + kb = dpc.create_kernel_bundle_from_source(q, oclSrc) addKernel = kb.get_sycl_kernel("add") n = 1024 * 1024 a = np.arange(n, dtype="i") - a_usm = dpctl_mem.MemoryUSMDevice(a.nbytes, queue=q) + a_usm = dpm.MemoryUSMDevice(a.nbytes, queue=q) ev1 = q.memcpy_async(dest=a_usm, src=a, count=a.nbytes) args = [a_usm] @@ -158,14 +158,14 @@ def test_get_wait_list(): size_t index = get_global_id(0); \ a[index] = sin(a[index]); \ }" - kb = dpctl_prog.create_kernel_bundle_from_source(q, oclSrc) + kb = dpc.create_kernel_bundle_from_source(q, oclSrc) addKernel = kb.get_sycl_kernel("add_k") sqrtKernel = kb.get_sycl_kernel("sqrt_k") sinKernel = kb.get_sycl_kernel("sin_k") n = 1024 * 1024 a = np.arange(n, dtype="f") - a_usm = dpctl_mem.MemoryUSMDevice(a.nbytes, queue=q) + a_usm = dpm.MemoryUSMDevice(a.nbytes, queue=q) ev_1 = q.memcpy_async(dest=a_usm, src=a, count=a.nbytes) args = [a_usm] @@ -200,8 +200,8 @@ def test_sycl_timer(): except dpctl.SyclQueueCreationError: pytest.skip("Queue creation of default device failed") timer = dpctl.SyclTimer() - m1 = dpctl_mem.MemoryUSMDevice(1024 * 1024, queue=q) - m2 = dpctl_mem.MemoryUSMDevice(1024 * 1024, queue=q) + m1 = dpm.MemoryUSMDevice(1024 * 1024, queue=q) + m2 = dpm.MemoryUSMDevice(1024 * 1024, queue=q) with timer(q): # device task m1.copy_from_device(m2) diff --git a/dpctl/tests/test_sycl_kernel_submit.py b/dpctl/tests/test_sycl_kernel_submit.py index 3ebab3244e..f18867b59c 100644 --- a/dpctl/tests/test_sycl_kernel_submit.py +++ b/dpctl/tests/test_sycl_kernel_submit.py @@ -23,8 +23,8 @@ import pytest import dpctl +import dpctl.compiler as dpc import dpctl.memory as dpm -import dpctl.program as dpctl_prog from dpctl._sycl_queue import kernel_arg_type @@ -59,7 +59,7 @@ def test_create_kernel_bundle_from_source(ctype_str, dtype, ctypes_ctor): " c[index] = d * a[index] + b[index];" "}" ) - kb = dpctl_prog.create_kernel_bundle_from_source(q, oclSrc) + kb = dpc.create_kernel_bundle_from_source(q, oclSrc) axpyKernel = kb.get_sycl_kernel("axpy") n_elems = 1024 * 512 @@ -174,14 +174,14 @@ def test_submit_async(): " (arg1[index] < arg2[index]) ? arg1[index] : arg2[index];" "}" ) - kb = dpctl_prog.create_kernel_bundle_from_source(q, oclSrc) + kb = dpc.create_kernel_bundle_from_source(q, oclSrc) kern1Kernel = kb.get_sycl_kernel("kern1") kern2Kernel = kb.get_sycl_kernel("kern2") kern3Kernel = kb.get_sycl_kernel("kern3") - assert isinstance(kern1Kernel, dpctl_prog.SyclKernel) - assert isinstance(kern2Kernel, dpctl_prog.SyclKernel) - assert isinstance(kern2Kernel, dpctl_prog.SyclKernel) + assert isinstance(kern1Kernel, dpc.SyclKernel) + assert isinstance(kern2Kernel, dpc.SyclKernel) + assert isinstance(kern2Kernel, dpc.SyclKernel) status_complete = dpctl.event_status_type.complete @@ -322,7 +322,7 @@ def test_submit_local_accessor_arg(): fn = get_spirv_abspath("local_accessor_kernel_inttys_fp32.spv") with open(fn, "br") as f: spirv_bytes = f.read() - kb = dpctl_prog.create_kernel_bundle_from_spirv(q, spirv_bytes) + kb = dpc.create_kernel_bundle_from_spirv(q, spirv_bytes) krn = kb.get_sycl_kernel("_ZTS14SyclKernel_SLMIlE") lws = 32 gws = lws * 10 diff --git a/dpctl/tests/test_sycl_program.py b/dpctl/tests/test_sycl_program.py index 564f40bed9..5b6a72672f 100644 --- a/dpctl/tests/test_sycl_program.py +++ b/dpctl/tests/test_sycl_program.py @@ -22,8 +22,8 @@ import pytest import dpctl -import dpctl.program as dpctl_prog -from dpctl.program.utils import parse_spirv_specializations +import dpctl.compiler as dpc +from dpctl.compiler.utils import parse_spirv_specializations def get_spirv_abspath(fn): @@ -38,7 +38,7 @@ def _check_cpython_api_SyclKernelBundle_GetKernelBundleRef(sycl_prog): import ctypes import sys - assert type(sycl_prog) is dpctl_prog.SyclKernelBundle + assert type(sycl_prog) is dpc.SyclKernelBundle mod = sys.modules[sycl_prog.__class__.__module__] # get capsule storing SyclKernelBundle_GetKernelBundleRef function ptr kb_ref_fn_cap = mod.__pyx_capi__["SyclKernelBundle_GetKernelBundleRef"] @@ -65,7 +65,7 @@ def _check_cpython_api_SyclKernelBundle_Make(sycl_prog): import ctypes import sys - assert type(sycl_prog) is dpctl_prog.SyclKernelBundle + assert type(sycl_prog) is dpc.SyclKernelBundle mod = sys.modules[sycl_prog.__class__.__module__] # get capsule storing SyclKernelBundle_Make function ptr make_prog_fn_cap = mod.__pyx_capi__["SyclKernelBundle_Make"] @@ -92,7 +92,7 @@ def _check_cpython_api_SyclKernel_GetKernelRef(krn): import ctypes import sys - assert type(krn) is dpctl_prog.SyclKernel + assert type(krn) is dpc.SyclKernel mod = sys.modules[krn.__class__.__module__] # get capsule storing SyclKernel_GetKernelRef function ptr k_ref_fn_cap = mod.__pyx_capi__["SyclKernel_GetKernelRef"] @@ -118,7 +118,7 @@ def _check_cpython_api_SyclKernel_Make(krn): import ctypes import sys - assert type(krn) is dpctl_prog.SyclKernel + assert type(krn) is dpc.SyclKernel mod = sys.modules[krn.__class__.__module__] # get capsule storing SyclKernel_Make function ptr k_make_fn_cap = mod.__pyx_capi__["SyclKernel_Make"] @@ -150,7 +150,7 @@ def _check_cpython_api_SyclKernel_Make(krn): def _check_multi_kernel_program(kb): - assert type(kb) is dpctl_prog.SyclKernelBundle + assert type(kb) is dpc.SyclKernelBundle assert type(kb.addressof_ref()) is int assert kb.has_sycl_kernel("add") @@ -205,7 +205,7 @@ def test_create_kernel_bundle_from_source_ocl(): q = dpctl.SyclQueue("opencl") except dpctl.SyclQueueCreationError: pytest.skip("No OpenCL queue is available") - kb = dpctl_prog.create_kernel_bundle_from_source(q, oclSrc) + kb = dpc.create_kernel_bundle_from_source(q, oclSrc) _check_multi_kernel_program(kb) @@ -217,7 +217,7 @@ def test_create_kernel_bundle_from_spirv_ocl(): spirv_file = get_spirv_abspath("multi_kernel.spv") with open(spirv_file, "rb") as fin: spirv = fin.read() - kb = dpctl_prog.create_kernel_bundle_from_spirv(q, spirv) + kb = dpc.create_kernel_bundle_from_spirv(q, spirv) _check_multi_kernel_program(kb) @@ -229,7 +229,7 @@ def test_create_kernel_bundle_from_spirv_l0(): spirv_file = get_spirv_abspath("multi_kernel.spv") with open(spirv_file, "rb") as fin: spirv = fin.read() - kb = dpctl_prog.create_kernel_bundle_from_spirv(q, spirv) + kb = dpc.create_kernel_bundle_from_spirv(q, spirv) _check_multi_kernel_program(kb) @@ -250,7 +250,7 @@ def test_create_kernel_bundle_from_source_l0(): size_t index = get_global_id(0); \ c[index] = a[index] + d*b[index]; \ }" - kb = dpctl_prog.create_kernel_bundle_from_source(q, oclSrc) + kb = dpc.create_kernel_bundle_from_source(q, oclSrc) _check_multi_kernel_program(kb) @@ -262,8 +262,8 @@ def test_create_kernel_bundle_from_invalid_src_ocl(): invalid_oclSrc = " \ kernel void add( \ }" - with pytest.raises(dpctl_prog.SyclKernelBundleCompilationError): - dpctl_prog.create_kernel_bundle_from_source(q, invalid_oclSrc) + with pytest.raises(dpc.SyclKernelBundleCompilationError): + dpc.create_kernel_bundle_from_source(q, invalid_oclSrc) def test_create_kernel_bundle_with_spec_const(): @@ -273,15 +273,13 @@ def test_create_kernel_bundle_with_spec_const(): pytest.skip("Could not create default queue") spec_id = 0 - sp = dpctl_prog.SpecializationConstant(spec_id, "i4", 42) + sp = dpc.SpecializationConstant(spec_id, "i4", 42) spirv_file = get_spirv_abspath("specialization_constant_kernel.spv") with open(spirv_file, "br") as spv: spv_bytes = spv.read() - kb = dpctl_prog.create_kernel_bundle_from_spirv( - q, spv_bytes, specializations=[sp] - ) + kb = dpc.create_kernel_bundle_from_spirv(q, spv_bytes, specializations=[sp]) kernel = kb.get_sycl_kernel("_ZTS20BasicSpecConstKernel") n = 128 @@ -311,15 +309,15 @@ def test_create_kernel_bundle_with_composite_spec_const(): # composite specialization constants are separated into individual # specialization constants with unique spec_ids - sp1 = dpctl_prog.SpecializationConstant(0, "i4", 10) - sp2 = dpctl_prog.SpecializationConstant(1, "f4", 2.5) - sp3 = dpctl_prog.SpecializationConstant(2, "?", 1) + sp1 = dpc.SpecializationConstant(0, "i4", 10) + sp2 = dpc.SpecializationConstant(1, "f4", 2.5) + sp3 = dpc.SpecializationConstant(2, "?", 1) spirv_file = get_spirv_abspath("specialization_constant_composite.spv") with open(spirv_file, "br") as spv: spv_bytes = spv.read() - kb = dpctl_prog.create_kernel_bundle_from_spirv( + kb = dpc.create_kernel_bundle_from_spirv( q, spv_bytes, specializations=[sp1, sp2, sp3] ) kernel = kb.get_sycl_kernel("_ZTS21StructSpecConstKernel") diff --git a/dpctl/tests/test_work_group_memory.py b/dpctl/tests/test_work_group_memory.py index 5f33f74162..97c44ed73c 100644 --- a/dpctl/tests/test_work_group_memory.py +++ b/dpctl/tests/test_work_group_memory.py @@ -62,7 +62,7 @@ def test_submit_work_group_memory(): spirv_file = get_spirv_abspath("work-group-memory-kernel.spv") with open(spirv_file, "br") as spv: spv_bytes = spv.read() - kb = dpctl.program.create_kernel_bundle_from_spirv(q, spv_bytes) + kb = dpctl.compiler.create_kernel_bundle_from_spirv(q, spv_bytes) kernel = kb.get_sycl_kernel("__sycl_kernel_local_mem_kernel") local_size = 16 global_size = local_size * 8 diff --git a/dpctl/tests/test_work_group_memory_opencl.py b/dpctl/tests/test_work_group_memory_opencl.py index 462c1940d1..178bc74e9d 100644 --- a/dpctl/tests/test_work_group_memory_opencl.py +++ b/dpctl/tests/test_work_group_memory_opencl.py @@ -45,7 +45,7 @@ def test_submit_work_group_memory_opencl(): except dpctl.SyclQueueCreationError: pytest.skip("OpenCL queue could not be created") - kb = dpctl.program.create_kernel_bundle_from_source(q, ocl_kernel_src) + kb = dpctl.compiler.create_kernel_bundle_from_source(q, ocl_kernel_src) kernel = kb.get_sycl_kernel("local_mem_kernel") local_size = 16 global_size = local_size * 8 diff --git a/examples/pybind11/use_dpctl_sycl_kernel/CMakeLists.txt b/examples/pybind11/use_dpctl_sycl_kernel/CMakeLists.txt index 5d8129581e..5bb2a98c6f 100644 --- a/examples/pybind11/use_dpctl_sycl_kernel/CMakeLists.txt +++ b/examples/pybind11/use_dpctl_sycl_kernel/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.21...3.27 FATAL_ERROR) project(use_queue_device VERSION 0.1 LANGUAGES CXX - DESCRIPTION "Example of using dpctl.program.SyclKernel <-> sycl::kernel type casting") + DESCRIPTION "Example of using dpctl.compiler.SyclKernel <-> sycl::kernel type casting") set(DPCTL_CMAKE_MODULES_PATH "${CMAKE_SOURCE_DIR}/../../../cmake") set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${DPCTL_CMAKE_MODULES_PATH}) diff --git a/examples/pybind11/use_dpctl_sycl_kernel/README.md b/examples/pybind11/use_dpctl_sycl_kernel/README.md index 77aa57bf6e..34fa8d96ad 100644 --- a/examples/pybind11/use_dpctl_sycl_kernel/README.md +++ b/examples/pybind11/use_dpctl_sycl_kernel/README.md @@ -3,7 +3,7 @@ ## Description This extension demonstrates how you can use dpctl Python types, -such as ``dpctl.SyclQueue`` and ``dpctl.program.SyclKernel``, in +such as ``dpctl.SyclQueue`` and ``dpctl.compiler.SyclKernel``, in Pybind11 extensions. diff --git a/examples/pybind11/use_dpctl_sycl_kernel/example.py b/examples/pybind11/use_dpctl_sycl_kernel/example.py index a164d2cd0b..e7678123bb 100644 --- a/examples/pybind11/use_dpctl_sycl_kernel/example.py +++ b/examples/pybind11/use_dpctl_sycl_kernel/example.py @@ -20,8 +20,8 @@ import use_kernel as eg import dpctl -import dpctl.memory as dpmem -import dpctl.program as dppr +import dpctl.compiler as dpc +import dpctl.memory as dpm # create execution queue, targeting default selected device q = dpctl.SyclQueue() @@ -31,7 +31,7 @@ il = fh.read() # Build the program for the selected device -pr = dppr.create_kernel_bundle_from_spirv(q, il, "") +pr = dpc.create_kernel_bundle_from_spirv(q, il, "") assert pr.has_sycl_kernel("double_it") # Retrieve the kernel from the problem @@ -41,8 +41,8 @@ # Construct the argument, and allocate memory for the result x = np.arange(0, stop=13, step=1, dtype="i4") y = np.empty_like(x) -x_dev = dpmem.MemoryUSMDevice(x.nbytes, queue=q) -y_dev = dpmem.MemoryUSMDevice(y.nbytes, queue=q) +x_dev = dpm.MemoryUSMDevice(x.nbytes, queue=q) +y_dev = dpm.MemoryUSMDevice(y.nbytes, queue=q) # Copy input data to the device q.memcpy(dest=x_dev, src=x, count=x.nbytes) diff --git a/examples/pybind11/use_dpctl_sycl_kernel/tests/test_user_kernel.py b/examples/pybind11/use_dpctl_sycl_kernel/tests/test_user_kernel.py index 805670bd8f..94e49282b8 100644 --- a/examples/pybind11/use_dpctl_sycl_kernel/tests/test_user_kernel.py +++ b/examples/pybind11/use_dpctl_sycl_kernel/tests/test_user_kernel.py @@ -23,8 +23,8 @@ import use_kernel as uk import dpctl -import dpctl.memory as dpmem -import dpctl.program as dppr +import dpctl.compiler as dpc +import dpctl.memory as dpm def _get_spv_path(): @@ -45,7 +45,7 @@ def test_kernel_can_be_found(): q = dpctl.SyclQueue() except dpctl.SyclQueueCreationError: pytest.skip("Could not create default queue") - kb = dppr.create_kernel_bundle_from_spirv(q, il, "") + kb = dpc.create_kernel_bundle_from_spirv(q, il, "") assert kb.has_sycl_kernel("double_it") @@ -57,15 +57,15 @@ def test_kernel_submit_through_extension(): q = dpctl.SyclQueue() except dpctl.SyclQueueCreationError: pytest.skip("Could not create default queue") - kb = dppr.create_kernel_bundle_from_spirv(q, il, "") + kb = dpc.create_kernel_bundle_from_spirv(q, il, "") krn = kb.get_sycl_kernel("double_it") assert krn.num_args == 2 x = np.arange(0, stop=13, step=1, dtype="i4") y = np.empty_like(x) - x_usm = dpmem.MemoryUSMDevice(x.nbytes, queue=q) - y_usm = dpmem.MemoryUSMDevice(y.nbytes, queue=q) + x_usm = dpm.MemoryUSMDevice(x.nbytes, queue=q) + y_usm = dpm.MemoryUSMDevice(y.nbytes, queue=q) ev = q.memcpy_async(dest=x_usm, src=x, count=x_usm.nbytes) diff --git a/examples/pybind11/use_dpctl_sycl_kernel/use_kernel/__init__.py b/examples/pybind11/use_dpctl_sycl_kernel/use_kernel/__init__.py index be771e1e31..cd5ddab5c3 100644 --- a/examples/pybind11/use_dpctl_sycl_kernel/use_kernel/__init__.py +++ b/examples/pybind11/use_dpctl_sycl_kernel/use_kernel/__init__.py @@ -27,7 +27,7 @@ SYCL entities. dpctl provides type casters that bind ``sycl::kernel`` to -`dpctl.program.SyclKernel`, ``sycl::device`` to `dpctl.SyclDevice`, etc. +`dpctl.compiler.SyclKernel`, ``sycl::device`` to `dpctl.SyclDevice`, etc. Use of these type casters simplifies writing of Python extensions and compile then using SYCL C++ compilers, such as Intel(R) oneAPI DPC++ compiler. diff --git a/examples/python/usm_memory_allocation.py b/examples/python/usm_memory_allocation.py index 0c23b8bd20..8259e7bef0 100644 --- a/examples/python/usm_memory_allocation.py +++ b/examples/python/usm_memory_allocation.py @@ -18,23 +18,23 @@ Demonstrates SYCL USM memory usage in Python using dpctl.memory. """ -import dpctl.memory as dpmem +import dpctl.memory as dpm # allocate USM-shared byte-buffer -ms = dpmem.MemoryUSMShared(16) +ms = dpm.MemoryUSMShared(16) # allocate USM-device byte-buffer -md = dpmem.MemoryUSMDevice(16) +md = dpm.MemoryUSMDevice(16) # allocate USM-host byte-buffer -mh = dpmem.MemoryUSMHost(16) +mh = dpm.MemoryUSMHost(16) # specify alignment -mda = dpmem.MemoryUSMDevice(128, alignment=16) +mda = dpm.MemoryUSMDevice(128, alignment=16) # allocate using given queue, # i.e. on the device and bound to the context stored in the queue -mdq = dpmem.MemoryUSMDevice(256, queue=mda.sycl_queue) +mdq = dpm.MemoryUSMDevice(256, queue=mda.sycl_queue) # information about device associate with USM buffer print("Allocation performed on device:") diff --git a/examples/python/usm_memory_host_access.py b/examples/python/usm_memory_host_access.py index f6af9c4305..6eb11c93d8 100644 --- a/examples/python/usm_memory_host_access.py +++ b/examples/python/usm_memory_host_access.py @@ -19,14 +19,14 @@ Python program. """ -import dpctl.memory as dpmem +import dpctl.memory as dpm # USM-shared and USM-host pointers are host-accessible, # meaning they are accessible from Python, therefore # they implement Python buffer protocol # allocate 1K of USM-shared buffer -ms = dpmem.MemoryUSMShared(1024) +ms = dpm.MemoryUSMShared(1024) # create memoryview into USM-shared buffer msv = memoryview(ms) @@ -36,7 +36,7 @@ ir = i % 256 msv[i] = ir**2 % 256 -mh = dpmem.MemoryUSMHost(64) +mh = dpm.MemoryUSMHost(64) mhv = memoryview(mh) # copy content of block of USM-shared buffer to @@ -47,7 +47,7 @@ print(list(mhv)) # USM-device buffer is not host accessible -md = dpmem.MemoryUSMDevice(16) +md = dpm.MemoryUSMDevice(16) try: mdv = memoryview(md) except Exception as e: diff --git a/examples/python/usm_memory_operation.py b/examples/python/usm_memory_operation.py index 7c52baca09..ac9dfb678c 100644 --- a/examples/python/usm_memory_operation.py +++ b/examples/python/usm_memory_operation.py @@ -20,10 +20,10 @@ import numpy as np -import dpctl.memory as dpmem +import dpctl.memory as dpm -ms = dpmem.MemoryUSMShared(32) -md = dpmem.MemoryUSMDevice(32) +ms = dpm.MemoryUSMShared(32) +md = dpm.MemoryUSMDevice(32) host_buf = np.random.randint(0, 42, dtype=np.uint8, size=32) diff --git a/setup.py b/setup.py index 2c44bd4a11..0d9472aeff 100644 --- a/setup.py +++ b/setup.py @@ -25,9 +25,10 @@ url="https://github.com/IntelPython/dpctl", packages=[ "dpctl", + "dpctl.compiler", + "dpctl.compiler.utils", "dpctl.memory", "dpctl.program", - "dpctl.program.utils", "dpctl.utils", ], package_data={ @@ -44,8 +45,9 @@ "include/syclinterface/Support/*.h", "include/dpctl/_sycl*.h", "include/dpctl/memory/_memory*.h", - "include/dpctl/program/_program*.h", + "include/dpctl/compiler/_compiler*.h", "*.pxd", + "compiler/*.pxd", "memory/*.pxd", "program/*.pxd", ]