kernelfoundry 0.1.0__tar.gz

kernelfoundry-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

kernelfoundry-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: kernelfoundry
+Version: 0.1.0
+Summary: A Python package for kernel testing
+Author-email: ISL Org <info@isl.org>
+Project-URL: Homepage, https://github.com/isl-org/code_gen_kernel.kernelfoundry
+Project-URL: Repository, https://github.com/isl-org/code_gen_kernel.kernelfoundry
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Requires-Dist: pytest
+Requires-Dist: pytest-dependency
+Requires-Dist: ninja
+Provides-Extra: dev
+Requires-Dist: black<27,>=26; extra == "dev"
+Requires-Dist: python-semantic-release; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.0; extra == "docs"
+Requires-Dist: shibuya; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Dynamic: license-file
+
+# KernelFoundry
+<img src="assets/kernelfoundry.png" alt="KernelFoundry Logo" width="200" align="right">
+
+KernelFoundry is a Python package for defining and evaluating GPU kernel tasks.
+
+This repository provides the **task-side test harness** used in kernel generation workflows:
+
+- A base task interface (``kernelfoundry.custom_test.CustomTest``) for implementing task-specific build and pytest test logic.
+- Build helpers for compiling candidate kernels into PyTorch extensions (via Torch or `icpx`).
+- Pytest fixtures for correctness/performance runs and collecting runtime data.
+- Validation helpers (`assert_allclose`, cosine similarity, and related utilities).
+- Runtime and machine-info helpers for benchmarking and metadata capture.
+
+In other words, this package is what you use to **author tasks and evaluate generated kernels**. The external orchestration layers (for example, UI/services that generate candidates) are separate from this repo.
+
+## Typical workflow
+
+1. Create a task test class by deriving from `kernelfoundry.custom_test.CustomTest`.
+2. Implement build logic (optional) and correctness/performance tests.
+3. Compile candidate kernel code with `compile_torch_extension(...)`.
+4. Run pytest to validate correctness and collect benchmark timings.
+
+KernelFoundry supports SYCL, OpenCL and CUDA kernels.
+
+### Installation
+
+Install the package and basic dependencies with
+
+```
+pip install .
+```
+
+The package requires Python 3.10+ (we commonly use Python 3.12). Install into a virtual environment if desired.
+
+The `kernelfoundry` package has minimal core dependencies. Depending on your task, you may also need framework/toolchain dependencies (for example PyTorch and GPU toolchains) to compile and test kernels locally.
+
+To run PyTorch-based tasks, install torch appropriate for your hardware:
+
+```
+# on Intel hardware:
+pip install torch==2.9.0 --index-url https://download.pytorch.org/whl/xpu
+# on NVIDIA hardware:
+pip install torch==2.9.0 --index-url https://download.pytorch.org/whl/cu129
+```
+
+### Documentation
+
+API documentation is available and can be built using Sphinx. To build the documentation:
+
+```
+pip install .[docs]
+cd docs
+make html
+```
+
+The generated documentation will be in `docs/_build/html/`. See the [docs/README.md](docs/README.md) for more information.

kernelfoundry-0.1.0/README.md

@@ -0,0 +1,56 @@
+# KernelFoundry
+<img src="assets/kernelfoundry.png" alt="KernelFoundry Logo" width="200" align="right">
+
+KernelFoundry is a Python package for defining and evaluating GPU kernel tasks.
+
+This repository provides the **task-side test harness** used in kernel generation workflows:
+
+- A base task interface (``kernelfoundry.custom_test.CustomTest``) for implementing task-specific build and pytest test logic.
+- Build helpers for compiling candidate kernels into PyTorch extensions (via Torch or `icpx`).
+- Pytest fixtures for correctness/performance runs and collecting runtime data.
+- Validation helpers (`assert_allclose`, cosine similarity, and related utilities).
+- Runtime and machine-info helpers for benchmarking and metadata capture.
+
+In other words, this package is what you use to **author tasks and evaluate generated kernels**. The external orchestration layers (for example, UI/services that generate candidates) are separate from this repo.
+
+## Typical workflow
+
+1. Create a task test class by deriving from `kernelfoundry.custom_test.CustomTest`.
+2. Implement build logic (optional) and correctness/performance tests.
+3. Compile candidate kernel code with `compile_torch_extension(...)`.
+4. Run pytest to validate correctness and collect benchmark timings.
+
+KernelFoundry supports SYCL, OpenCL and CUDA kernels.
+
+### Installation
+
+Install the package and basic dependencies with
+
+```
+pip install .
+```
+
+The package requires Python 3.10+ (we commonly use Python 3.12). Install into a virtual environment if desired.
+
+The `kernelfoundry` package has minimal core dependencies. Depending on your task, you may also need framework/toolchain dependencies (for example PyTorch and GPU toolchains) to compile and test kernels locally.
+
+To run PyTorch-based tasks, install torch appropriate for your hardware:
+
+```
+# on Intel hardware:
+pip install torch==2.9.0 --index-url https://download.pytorch.org/whl/xpu
+# on NVIDIA hardware:
+pip install torch==2.9.0 --index-url https://download.pytorch.org/whl/cu129
+```
+
+### Documentation
+
+API documentation is available and can be built using Sphinx. To build the documentation:
+
+```
+pip install .[docs]
+cd docs
+make html
+```
+
+The generated documentation will be in `docs/_build/html/`. See the [docs/README.md](docs/README.md) for more information.

kernelfoundry-0.1.0/docs/conf.py

@@ -0,0 +1,90 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+import os
+import sys
+
+# Add the project root directory to sys.path
+sys.path.insert(0, os.path.abspath(".."))
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = "kernelfoundry"
+copyright = "2026, Intel"
+author = "Intel"
+
+# The version info for the project
+from kernelfoundry import __version__
+
+version = __version__
+release = __version__
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
+    "sphinx.ext.intersphinx",
+    "sphinx_copybutton",
+]
+
+# Turn on sphinx.ext.autosummary
+autosummary_generate = True
+
+# Napoleon settings for Google-style docstrings
+napoleon_google_docstring = True
+napoleon_numpy_docstring = False
+napoleon_include_init_with_doc = True
+napoleon_include_private_with_doc = False
+napoleon_include_special_with_doc = True
+napoleon_use_admonition_for_examples = False
+napoleon_use_admonition_for_notes = False
+napoleon_use_admonition_for_references = False
+napoleon_use_ivar = False
+napoleon_use_param = True
+napoleon_use_rtype = True
+napoleon_preprocess_types = False
+napoleon_type_aliases = None
+napoleon_attr_annotations = True
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "shibuya"
+html_static_path = ["_static"]
+html_theme_options = {
+    "globaltoc_expand_depth": 2,
+    "show_ai_links": False,
+}
+html_css_files = [
+    "custom.css",
+]
+
+# -- Options for autodoc -----------------------------------------------------
+autodoc_default_options = {
+    "members": True,
+    "member-order": "bysource",
+    "special-members": "__init__",
+    "undoc-members": True,
+    "exclude-members": "__weakref__",
+    "private-members": False,
+}
+
+# -- Intersphinx mapping -----------------------------------------------------
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3", None),
+    "numpy": ("https://numpy.org/doc/stable/", None),
+}

kernelfoundry-0.1.0/kernelfoundry/__init__.py

@@ -0,0 +1,3 @@
+"""kernelfoundry - Python package for KernelFoundry the GPU kernel generation tool."""
+
+__version__ = "0.1.0"

kernelfoundry-0.1.0/kernelfoundry/compiler.py

@@ -0,0 +1,239 @@
+"""Kernel compilation helpers for building PyTorch extensions.
+
+See :func:`kernelfoundry.custom_test.CustomTask.compile_torch_extension`
+for a high-level interface.
+"""
+
+import os
+import subprocess
+import shlex
+import sys
+import textwrap
+from pathlib import Path
+import sysconfig
+import warnings
+from abc import ABC, abstractmethod
+
+try:
+    from torch.utils.cpp_extension import _get_pybind11_abi_build_flags, include_paths, TORCH_LIB_PATH
+except ImportError:
+    warnings.warn("Torch not installed, note that IcpxCompiler will not work.")
+
+
+class BaseKernelCompiler(ABC):
+    """Abstract base class for kernel compilers."""
+
+    def __init__(
+        self, extension_name: str, src: str, build_dir: str, gpu_arch: str, timeout: int = 120, verbose: bool = False
+    ):
+        """
+        Initialize the Compiler.
+
+        Args:
+            extension_name (str): Name of the PyTorch extension to build.
+            src (str): Path to the source file.
+            build_dir (str): Directory to store the compiled outputs.
+            gpu_arch (str): GPU architecture string.
+            timeout (int): Timeout for each compilation step in seconds.
+            verbose (bool): Whether to enable verbose output.
+        """
+        self.extension_name = extension_name
+        self.src = src
+        self.build_dir = build_dir
+        self.gpu_arch = gpu_arch
+        self.timeout = timeout
+        self.verbose = verbose
+
+        # Ensure output directory exists
+        Path(self.build_dir).mkdir(parents=True, exist_ok=True)
+
+    @abstractmethod
+    def compile(self):
+        pass
+
+
+class TorchCompiler(BaseKernelCompiler):
+    """Compiler class using the torch cpp_extension compiler."""
+
+    def compile(self):
+        args = {
+            "sources": self.src,
+            "name": self.extension_name,
+            "verbose": self.verbose,
+            "build_directory": self.build_dir,
+        }
+
+        code = textwrap.dedent(f"""
+            import os, sys, json, traceback
+            try:
+                from torch.utils.cpp_extension import load
+                args = {args}
+                load(**args)
+            except Exception as e:
+                sys.stderr.write(str(e) + "\\n")
+                sys.stderr.write(traceback.format_exc() + "\\n")
+                sys.exit(1)
+        """)
+        env = os.environ.copy()
+        env["TORCH_CUDA_ARCH_LIST"] = self.gpu_arch
+        env["TORCH_XPU_ARCH_LIST"] = self.gpu_arch
+
+        try:
+            process = subprocess.Popen(
+                [sys.executable, "-c", code], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env
+            )
+            stdout, stderr = process.communicate(timeout=self.timeout)
+            returncode = process.returncode
+            return {
+                "stdout": stdout.decode("utf-8"),
+                "stderr": stderr.decode("utf-8"),
+                "returncode": returncode,
+            }
+        except subprocess.TimeoutExpired as e:
+            process.kill()
+            stdout, stderr = process.communicate()
+            returncode = process.returncode
+            return {
+                "stdout": stdout.decode("utf-8"),
+                "stderr": stderr.decode("utf-8") + f"\nCompilation timed out: {e}",
+                "returncode": returncode,
+            }
+
+
+class IcpxCompiler(BaseKernelCompiler):
+    """Compiler class for SYCL programs using the Intel icpx compiler."""
+
+    def compile(self):
+        """Compile the SYCL program into a PyTorch extension."""
+
+        stdout_all = []
+        stderr_all = []
+
+        try:
+            # Step 1: Compile SYCL source to object file
+            obj_file = f"{self.build_dir}/{Path(self.src).stem}.sycl.o"
+            stdout, stderr = self._compile_to_object(obj_file)
+            stdout_all.append(stdout)
+            stderr_all.append(stderr)
+
+            # Step 2: Generate SYCL device binary
+            sycl_dlink_file = f"{self.build_dir}/sycl_dlink.o"
+            stdout, stderr = self._generate_device_binary(obj_file, sycl_dlink_file)
+            stdout_all.append(stdout)
+            stderr_all.append(stderr)
+
+            # Step 3: Link object file and device binary into a shared library
+            shared_lib = f"{self.build_dir}/{self.extension_name}.so"
+            stdout, stderr = self._link_shared_library(obj_file, sycl_dlink_file, shared_lib)
+            stdout_all.append(stdout)
+            stderr_all.append(stderr)
+
+            return {
+                "stdout": "\n".join(stdout_all),
+                "stderr": "\n".join(stderr_all),
+                "returncode": 0,
+            }
+        except (RuntimeError, subprocess.TimeoutExpired) as e:
+            stderr_all.append(str(e))
+            return {
+                "stdout": "\n".join(stdout_all),
+                "stderr": "\n".join(stderr_all),
+                "returncode": 1,
+            }
+
+    def _compile_to_object(self, obj_file: Path):
+        """Compile the SYCL source file to an object file."""
+        cflags = []
+        cflags.append(f"-DTORCH_EXTENSION_NAME={self.extension_name}")
+        cflags.append("-DTORCH_API_INCLUDE_EXTENSION_H")
+
+        cflags += [f"{x}" for x in _get_pybind11_abi_build_flags()]
+
+        system_includes = include_paths("cpu")
+        python_include_path = sysconfig.get_path("include", scheme="posix_prefix")
+        if python_include_path is not None:
+            system_includes.append(python_include_path)
+
+        cflags += [f"-isystem {shlex.quote(include)}" for include in system_includes]
+        cflags.append("-fPIC")
+        cflags.append("-std=c++17")
+
+        sycl_cflags = []
+        sycl_cflags.append("-fsycl")
+        sycl_cflags.append("-fsycl-targets=spir64_gen,spir64")
+        sycl_cflags.append("-sycl-std=2020")
+        # sycl_cflags.append("-fsycl-host-compiler=c++")
+
+        host_cflags = cflags
+        host_cflags = [item.replace('\\"', '\\\\"') for item in host_cflags]
+        host_cflags = " ".join(host_cflags)
+
+        # sycl_cflags.append(shlex.quote(f"-fsycl-host-compiler-options={host_cflags}"))
+
+        cmd = ["icpx"] + cflags + sycl_cflags + ["-c", "-x", "c++", str(self.src), "-o", str(obj_file)]
+
+        cmd = " ".join(cmd)
+
+        return self._run_command(cmd, "Compiling SYCL source to object file")
+
+    def _generate_device_binary(self, obj_file: Path, sycl_dlink_file: Path):
+        """Generate the SYCL device binary."""
+        cmd = [
+            "icpx",
+            str(obj_file),
+            "-o",
+            str(sycl_dlink_file),
+            "-fsycl",
+            "-fsycl-link",
+            "--offload-compress",
+            "-fsycl-targets=spir64_gen,spir64",
+        ]
+        arch_list = self.gpu_arch
+        if arch_list != "":
+            cmd += [f'-Xs "-device {arch_list}"']
+        cmd = " ".join(cmd)
+        return self._run_command(cmd, "Generating SYCL device binary")
+
+    def _link_shared_library(self, obj_file: Path, sycl_dlink_file: Path, shared_lib: Path):
+        """Link the object file and device binary into a shared library."""
+        cmd = [
+            "c++",
+            str(obj_file),
+            str(sycl_dlink_file),
+            "-shared",
+            f"-L{TORCH_LIB_PATH}",
+            "-lc10",
+            "-ltorch_cpu",
+            "-ltorch",
+            "-ltorch_python",
+            "-o",
+            str(shared_lib),
+        ]
+        cmd = " ".join(cmd)
+        return self._run_command(cmd, "Linking shared library")
+
+    def _run_command(self, cmd: list, description: str):
+        try:
+            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, text=True)
+            stdout, stderr = process.communicate(timeout=self.timeout)
+            returncode = process.returncode
+            print(stdout)
+            print(stderr)
+            if returncode != 0:
+                raise RuntimeError(f"[ERROR] {description} failed")
+            return stdout, stderr
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"[ERROR] {description} failed: {e}")
+
+
+if __name__ == "__main__":
+    compiler = IcpxCompiler(
+        extension_name="pytorch_operation_v1",
+        src="runs/test/generated_kernel_level_1_problem_19_trial_1_v0.sycl",
+        build_dir="runs/test/build",
+    )
+    result = compiler.compile()
+    if result["returncode"] == 0:
+        print(f"[INFO] Compilation succeeded.")
+    else:
+        print(f"[ERROR] Compilation failed. Error: {result['stderr']}")