From 53df1bce8ea42bb325ab7e45391d1c322304ae98 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Fri, 24 Oct 2025 17:32:56 -0400 Subject: [PATCH 01/24] use pass name from transform --- .github/workflows/check-catalyst.yaml | 12 +++++++ frontend/catalyst/from_plxpr/from_plxpr.py | 41 +++++++++++----------- frontend/catalyst/jax_primitives_utils.py | 16 +++++++-- 3 files changed, 46 insertions(+), 23 deletions(-) diff --git a/.github/workflows/check-catalyst.yaml b/.github/workflows/check-catalyst.yaml index 999e5ad137..2f97fec69d 100644 --- a/.github/workflows/check-catalyst.yaml +++ b/.github/workflows/check-catalyst.yaml @@ -475,6 +475,10 @@ jobs: python3 -m pip install oqc-qcaas-client make frontend + - name: Install PennyLane branch + run: | + pip install --no-deps --force git+https://github.com/PennyLaneAI/pennylane@add-pass-name + - name: Get Cached LLVM Build id: cache-llvm-build uses: actions/cache@v4 @@ -558,6 +562,10 @@ jobs: python3 -m pip install -r requirements.txt make frontend + - name: Install PennyLane branch + run: | + pip install --no-deps --force git+https://github.com/PennyLaneAI/pennylane@add-pass-name + - name: Get Cached LLVM Build id: cache-llvm-build uses: actions/cache@v4 @@ -620,6 +628,10 @@ jobs: python3 -m pip install -r requirements.txt make frontend + - name: Install PennyLane branch + run: | + pip install --no-deps --force git+https://github.com/PennyLaneAI/pennylane@add-pass-name + - name: Get Cached LLVM Build id: cache-llvm-build uses: actions/cache@v4 diff --git a/frontend/catalyst/from_plxpr/from_plxpr.py b/frontend/catalyst/from_plxpr/from_plxpr.py index 64d74400ba..a949c5968c 100644 --- a/frontend/catalyst/from_plxpr/from_plxpr.py +++ b/frontend/catalyst/from_plxpr/from_plxpr.py @@ -138,7 +138,7 @@ class WorkflowInterpreter(PlxprInterpreter): """An interpreter that converts a qnode primitive from a plxpr variant to a catalyst jaxpr variant.""" def __init__(self): - self._pass_pipeline = [] + self._pass_pipeline = qml.transforms.core.TransformProgram() self.init_qreg = None # Compiler options for the new decomposition system @@ -231,23 +231,22 @@ def calling_convention(*args): # The map below describes the parity between PL transforms and Catalyst passes. -# PL transforms having a Catalyst pass counterpart will have a name as value, -# otherwise their value will be None. The second value indicates if the transform +# The value indicates if the transform # requires decomposition to be supported by Catalyst. transforms_to_passes = { - pl_cancel_inverses: ("remove-chained-self-inverse", False), - pl_commute_controlled: (None, False), - pl_decompose: (None, False), - pl_map_wires: (None, False), - pl_merge_amplitude_embedding: (None, True), - pl_merge_rotations: ("merge-rotations", False), - pl_single_qubit_fusion: (None, False), - pl_unitary_to_rot: (None, False), + pl_cancel_inverses: False, + pl_commute_controlled: False, + pl_decompose: False, + pl_map_wires: False, + pl_merge_amplitude_embedding: True, + pl_merge_rotations: False, + pl_single_qubit_fusion: False, + pl_unitary_to_rot: False, } # pylint: disable-next=redefined-outer-name -def register_transform(pl_transform, pass_name, decomposition): +def register_transform(pl_transform, decomposition): """Register pennylane transforms and their conversion to Catalyst transforms""" # pylint: disable=too-many-arguments @@ -260,9 +259,8 @@ def handle_transform( inner_jaxpr, targs_slice, tkwargs, - catalyst_pass_name=pass_name, requires_decomposition=decomposition, - pl_plxpr_transform=pl_transform._plxpr_transform, + transform=pl_transform, ): """Handle the conversion from plxpr to Catalyst jaxpr for a PL transform.""" @@ -273,8 +271,8 @@ def handle_transform( # If the transform is a decomposition transform # and the graph-based decomposition is enabled if ( - hasattr(pl_plxpr_transform, "__name__") - and pl_plxpr_transform.__name__ == "decompose_plxpr_to_plxpr" + hasattr(transform._plxpr_transform, "__name__") + and transform._plxpr_transform.__name__ == "decompose_plxpr_to_plxpr" and qml.decomposition.enabled_graph() ): if not self.requires_decompose_lowering: @@ -315,7 +313,7 @@ def handle_transform( # return self.eval(final_jaxpr.jaxpr, consts, *non_const_args) return self.eval(inner_jaxpr, consts, *non_const_args) - if catalyst_pass_name is None: + if transform.pass_name is None: # Use PL's ExpandTransformsInterpreter to expand this and any embedded # transform according to PL rules. It works by overriding the primitive # registration, making all embedded transforms follow the PL rules @@ -324,7 +322,7 @@ def wrapper(*args): return ExpandTransformsInterpreter().eval(inner_jaxpr, consts, *args) unravelled_jaxpr = jax.make_jaxpr(wrapper)(*non_const_args) - final_jaxpr = pl_plxpr_transform( + final_jaxpr = transform._plxpr_transform( unravelled_jaxpr.jaxpr, unravelled_jaxpr.consts, targs, tkwargs, *non_const_args ) @@ -336,7 +334,8 @@ def wrapper(*args): return self.eval(final_jaxpr.jaxpr, final_jaxpr.consts, *non_const_args) # Apply the corresponding Catalyst pass counterpart - self._pass_pipeline.insert(0, Pass(catalyst_pass_name)) + container = qml.transforms.core.TransformContainer(transform, args=targs, kwargs=tkwargs) + self._pass_pipeline.insert_front(container) return self.eval(inner_jaxpr, consts, *non_const_args) @@ -344,8 +343,8 @@ def wrapper(*args): # across the map above and generates a custom handler for each transform. # In order to ensure early binding, we pass the PL plxpr transform and the # Catalyst pass as arguments whose default values are set by the loop. -for pl_transform, (pass_name, decomposition) in transforms_to_passes.items(): - register_transform(pl_transform, pass_name, decomposition) +for pl_transform, decomposition in transforms_to_passes.items(): + register_transform(pl_transform, decomposition) # pylint: disable=too-many-positional-arguments diff --git a/frontend/catalyst/jax_primitives_utils.py b/frontend/catalyst/jax_primitives_utils.py index 1227b7f1b5..ab52e9a5cd 100644 --- a/frontend/catalyst/jax_primitives_utils.py +++ b/frontend/catalyst/jax_primitives_utils.py @@ -308,6 +308,13 @@ def __exit__(self, exc_type, exc_val, exc_tb): self.ctx.module_context = self.old_module_context +def _lowered_options(kwargs): + lowered_options = {} + for option, value in kwargs.items(): + mlir_option = str(option).replace("_", "-") + lowered_options[mlir_option] = get_mlir_attribute_from_pyval(value) + return lowered_options + def transform_named_sequence_lowering(jax_ctx: mlir.LoweringRuleContext, pipeline): """Generate a transform module embedded in the current module and schedule the transformations in pipeline""" @@ -350,11 +357,16 @@ def transform_named_sequence_lowering(jax_ctx: mlir.LoweringRuleContext, pipelin with ir.InsertionPoint(bb_named_sequence): target = bb_named_sequence.arguments[0] for _pass in pipeline: - options = _pass.get_options() + if isinstance(_pass, qml.transforms.core.TransformContainer): + options = _lowered_options(_pass.kwargs) + name = _pass.pass_name + else: + options = _pass.get_options() + name = _pass.name apply_registered_pass_op = ApplyRegisteredPassOp( result=transform_mod_type, target=target, - pass_name=_pass.name, + pass_name=name, options=options, dynamic_options={}, ) From cf0150129523ba8656cda8289c405b0b95d319e4 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Mon, 3 Nov 2025 13:47:17 -0500 Subject: [PATCH 02/24] some udpates --- frontend/catalyst/from_plxpr/__init__.py | 2 +- frontend/catalyst/from_plxpr/from_plxpr.py | 199 +++++++++------------ 2 files changed, 87 insertions(+), 114 deletions(-) diff --git a/frontend/catalyst/from_plxpr/__init__.py b/frontend/catalyst/from_plxpr/__init__.py index a39039fe1d..3599025f6e 100644 --- a/frontend/catalyst/from_plxpr/__init__.py +++ b/frontend/catalyst/from_plxpr/__init__.py @@ -15,4 +15,4 @@ """Conversion from plxpr to catalyst jaxpr""" from catalyst.from_plxpr.control_flow import handle_cond, handle_for_loop, handle_while_loop -from catalyst.from_plxpr.from_plxpr import from_plxpr, register_transform, trace_from_pennylane +from catalyst.from_plxpr.from_plxpr import from_plxpr, trace_from_pennylane diff --git a/frontend/catalyst/from_plxpr/from_plxpr.py b/frontend/catalyst/from_plxpr/from_plxpr.py index a949c5968c..9e3f93e691 100644 --- a/frontend/catalyst/from_plxpr/from_plxpr.py +++ b/frontend/catalyst/from_plxpr/from_plxpr.py @@ -27,14 +27,9 @@ from jax.extend.linear_util import wrap_init from pennylane.capture import PlxprInterpreter, qnode_prim from pennylane.capture.expand_transforms import ExpandTransformsInterpreter -from pennylane.ops.functions.map_wires import _map_wires_transform as pl_map_wires -from pennylane.transforms import cancel_inverses as pl_cancel_inverses -from pennylane.transforms import commute_controlled as pl_commute_controlled from pennylane.transforms import decompose as pl_decompose from pennylane.transforms import merge_amplitude_embedding as pl_merge_amplitude_embedding -from pennylane.transforms import merge_rotations as pl_merge_rotations -from pennylane.transforms import single_qubit_fusion as pl_single_qubit_fusion -from pennylane.transforms import unitary_to_rot as pl_unitary_to_rot +from pennylane.transforms.core.transform_dispatcher import _create_transform_primitive from catalyst.device import extract_backend_info from catalyst.from_plxpr.decompose import COMPILER_OPS_FOR_DECOMPOSITION, DecompRuleInterpreter @@ -54,6 +49,8 @@ QubitIndexRecorder, ) +transform_prim = _create_transform_primitive() + def _get_device_kwargs(device) -> dict: """Calulcate the params for a device equation.""" @@ -226,125 +223,101 @@ def calling_convention(*args): wrap_init(calling_convention, debug_info=qfunc_jaxpr.debug_info), *non_const_args, qnode=qnode, - pipeline=self._pass_pipeline, + pipeline=tuple(self._pass_pipeline), ) -# The map below describes the parity between PL transforms and Catalyst passes. -# The value indicates if the transform -# requires decomposition to be supported by Catalyst. -transforms_to_passes = { - pl_cancel_inverses: False, - pl_commute_controlled: False, - pl_decompose: False, - pl_map_wires: False, - pl_merge_amplitude_embedding: True, - pl_merge_rotations: False, - pl_single_qubit_fusion: False, - pl_unitary_to_rot: False, -} - - -# pylint: disable-next=redefined-outer-name -def register_transform(pl_transform, decomposition): - """Register pennylane transforms and their conversion to Catalyst transforms""" - - # pylint: disable=too-many-arguments - @WorkflowInterpreter.register_primitive(pl_transform._primitive) - def handle_transform( - self, - *args, - args_slice, - consts_slice, - inner_jaxpr, - targs_slice, - tkwargs, - requires_decomposition=decomposition, - transform=pl_transform, +require_decomposition_transforms = {pl_merge_amplitude_embedding} + + +# pylint: disable=too-many-arguments +@WorkflowInterpreter.register_primitive(transform_prim) +def handle_transform( + self, + *args, + args_slice, + consts_slice, + inner_jaxpr, + targs_slice, + tkwargs, + transform, +): + """Handle the conversion from plxpr to Catalyst jaxpr for a + PL transform.""" + consts = args[consts_slice] + non_const_args = args[args_slice] + targs = args[targs_slice] + + # If the transform is a decomposition transform + # and the graph-based decomposition is enabled + if ( + hasattr(transform._plxpr_transform, "__name__") + and transform._plxpr_transform.__name__ == "decompose_plxpr_to_plxpr" + and qml.decomposition.enabled_graph() ): - """Handle the conversion from plxpr to Catalyst jaxpr for a - PL transform.""" - consts = args[consts_slice] - non_const_args = args[args_slice] - targs = args[targs_slice] - - # If the transform is a decomposition transform - # and the graph-based decomposition is enabled - if ( - hasattr(transform._plxpr_transform, "__name__") - and transform._plxpr_transform.__name__ == "decompose_plxpr_to_plxpr" - and qml.decomposition.enabled_graph() - ): - if not self.requires_decompose_lowering: - self.requires_decompose_lowering = True - else: - raise NotImplementedError( - "Multiple decomposition transforms are not yet supported." - ) - - # Update the decompose_gateset to be used by the quantum kernel primitive - # TODO: we originally wanted to treat decompose_gateset as a queue of - # gatesets to be used by the decompose-lowering pass at MLIR - # but this requires a C++ implementation of the graph-based decomposition - # which doesn't exist yet. - self.decompose_tkwargs = tkwargs - - # Note. We don't perform the compiler-specific decomposition here - # to be able to support multiple decomposition transforms - # and collect all the required gatesets - # as well as being able to support other transforms in between. - - # The compiler specific transformation will be performed - # in the qnode handler. - - # Add the decompose-lowering pass to the start of the pipeline - self._pass_pipeline.insert(0, Pass("decompose-lowering")) - - # We still need to construct and solve the graph based on - # the current jaxpr based on the current gateset - # but we don't rewrite the jaxpr at this stage. - - # gds_interpreter = DecompRuleInterpreter(*targs, **tkwargs) - - # def gds_wrapper(*args): - # return gds_interpreter.eval(inner_jaxpr, consts, *args) - - # final_jaxpr = jax.make_jaxpr(gds_wrapper)(*args) - # return self.eval(final_jaxpr.jaxpr, consts, *non_const_args) - return self.eval(inner_jaxpr, consts, *non_const_args) - - if transform.pass_name is None: - # Use PL's ExpandTransformsInterpreter to expand this and any embedded - # transform according to PL rules. It works by overriding the primitive - # registration, making all embedded transforms follow the PL rules - # from now on, hence ignoring the Catalyst pass conversion - def wrapper(*args): - return ExpandTransformsInterpreter().eval(inner_jaxpr, consts, *args) - - unravelled_jaxpr = jax.make_jaxpr(wrapper)(*non_const_args) - final_jaxpr = transform._plxpr_transform( - unravelled_jaxpr.jaxpr, unravelled_jaxpr.consts, targs, tkwargs, *non_const_args + if not self.requires_decompose_lowering: + self.requires_decompose_lowering = True + else: + raise NotImplementedError( + "Multiple decomposition transforms are not yet supported." ) - if requires_decomposition: - final_jaxpr = pl_decompose._plxpr_transform( - final_jaxpr.jaxpr, final_jaxpr.consts, targs, tkwargs, *non_const_args - ) + # Update the decompose_gateset to be used by the quantum kernel primitive + # TODO: we originally wanted to treat decompose_gateset as a queue of + # gatesets to be used by the decompose-lowering pass at MLIR + # but this requires a C++ implementation of the graph-based decomposition + # which doesn't exist yet. + self.decompose_tkwargs = tkwargs - return self.eval(final_jaxpr.jaxpr, final_jaxpr.consts, *non_const_args) + # Note. We don't perform the compiler-specific decomposition here + # to be able to support multiple decomposition transforms + # and collect all the required gatesets + # as well as being able to support other transforms in between. - # Apply the corresponding Catalyst pass counterpart - container = qml.transforms.core.TransformContainer(transform, args=targs, kwargs=tkwargs) + # The compiler specific transformation will be performed + # in the qnode handler. + + # Add the decompose-lowering pass to the start of the pipeline + container = qml.transforms.core.TransformContainer(qml.transforms.decompose) self._pass_pipeline.insert_front(container) + # We still need to construct and solve the graph based on + # the current jaxpr based on the current gateset + # but we don't rewrite the jaxpr at this stage. + + # gds_interpreter = DecompRuleInterpreter(*targs, **tkwargs) + + # def gds_wrapper(*args): + # return gds_interpreter.eval(inner_jaxpr, consts, *args) + + # final_jaxpr = jax.make_jaxpr(gds_wrapper)(*args) + # return self.eval(final_jaxpr.jaxpr, consts, *non_const_args) return self.eval(inner_jaxpr, consts, *non_const_args) + if transform.pass_name is None: + # Use PL's ExpandTransformsInterpreter to expand this and any embedded + # transform according to PL rules. It works by overriding the primitive + # registration, making all embedded transforms follow the PL rules + # from now on, hence ignoring the Catalyst pass conversion + def wrapper(*args): + return ExpandTransformsInterpreter().eval(inner_jaxpr, consts, *args) + + unravelled_jaxpr = jax.make_jaxpr(wrapper)(*non_const_args) + final_jaxpr = transform._plxpr_transform( + unravelled_jaxpr.jaxpr, unravelled_jaxpr.consts, targs, tkwargs, *non_const_args + ) + + if transform in require_decomposition_transforms: + final_jaxpr = pl_decompose._plxpr_transform( + final_jaxpr.jaxpr, final_jaxpr.consts, targs, tkwargs, *non_const_args + ) + + return self.eval(final_jaxpr.jaxpr, final_jaxpr.consts, *non_const_args) + + # Apply the corresponding Catalyst pass counterpart + container = qml.transforms.core.TransformContainer(transform, args=targs, kwargs=tkwargs) + self._pass_pipeline.insert_front(container) + return self.eval(inner_jaxpr, consts, *non_const_args) -# This is our registration factory for PL transforms. The loop below iterates -# across the map above and generates a custom handler for each transform. -# In order to ensure early binding, we pass the PL plxpr transform and the -# Catalyst pass as arguments whose default values are set by the loop. -for pl_transform, decomposition in transforms_to_passes.items(): - register_transform(pl_transform, decomposition) # pylint: disable=too-many-positional-arguments From a08905b25b49cd5a8b903b7ac0bf21ccce7acb15 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Wed, 5 Nov 2025 12:03:14 -0500 Subject: [PATCH 03/24] make backwards compatible --- frontend/catalyst/from_plxpr/from_plxpr.py | 970 ++++++++++++--------- frontend/catalyst/qfunc.py | 27 +- 2 files changed, 599 insertions(+), 398 deletions(-) diff --git a/frontend/catalyst/from_plxpr/from_plxpr.py b/frontend/catalyst/from_plxpr/from_plxpr.py index 9e3f93e691..16997f3cf6 100644 --- a/frontend/catalyst/from_plxpr/from_plxpr.py +++ b/frontend/catalyst/from_plxpr/from_plxpr.py @@ -1,4 +1,4 @@ -# Copyright 2024 Xanadu Quantum Technologies Inc. +# Copyright 2022-2024 Xanadu Quantum Technologies Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -11,474 +11,660 @@ # 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. + """ -This submodule defines a utility for converting plxpr into Catalyst jaxpr. +This module contains a patch for the upstream qml.QNode behaviour, in particular around +what happens when a QNode object is called during tracing. Mostly this involves bypassing +the default behaviour and replacing it with a function-like "QNode" primitive. """ -# pylint: disable=protected-access - - -import warnings -from functools import partial -from typing import Callable +import logging +from copy import copy +from dataclasses import dataclass, replace +from typing import Callable, Sequence -import jax +import jax.numpy as jnp import pennylane as qml -from jax.extend.core import ClosedJaxpr, Jaxpr -from jax.extend.linear_util import wrap_init -from pennylane.capture import PlxprInterpreter, qnode_prim -from pennylane.capture.expand_transforms import ExpandTransformsInterpreter -from pennylane.transforms import decompose as pl_decompose -from pennylane.transforms import merge_amplitude_embedding as pl_merge_amplitude_embedding -from pennylane.transforms.core.transform_dispatcher import _create_transform_primitive - -from catalyst.device import extract_backend_info -from catalyst.from_plxpr.decompose import COMPILER_OPS_FOR_DECOMPOSITION, DecompRuleInterpreter -from catalyst.jax_extras import make_jaxpr2, transient_jax_config -from catalyst.jax_primitives import ( - device_init_p, - device_release_p, - qalloc_p, - qdealloc_p, - quantum_kernel_p, +from jax.core import eval_jaxpr +from jax.tree_util import tree_flatten, tree_unflatten +from pennylane import exceptions +from pennylane.measurements import CountsMP, ExpectationMP, ProbabilityMP, SampleMP, VarianceMP +from pennylane.transforms.dynamic_one_shot import ( + gather_non_mcm, + init_auxiliary_tape, + parse_native_mid_circuit_measurements, ) -from catalyst.passes.pass_api import Pass -from .qfunc_interpreter import PLxPRToQuantumJaxprInterpreter -from .qubit_handler import ( - QubitHandler, - QubitIndexRecorder, -) +import catalyst +from catalyst.api_extensions import MidCircuitMeasure +from catalyst.device import QJITDevice +from catalyst.device.qjit_device import is_dynamic_wires +from catalyst.jax_extras import deduce_avals, get_implicit_and_explicit_flat_args, unzip2 +from catalyst.jax_extras.tracing import uses_transform +from catalyst.jax_primitives import quantum_kernel_p +from catalyst.jax_tracer import Function, trace_quantum_function +from catalyst.logging import debug_logger +from catalyst.passes.pass_api import dictionary_to_list_of_passes, Pass +from catalyst.tracing.contexts import EvaluationContext +from catalyst.tracing.type_signatures import filter_static_args +from catalyst.utils.exceptions import CompileError + +logger = logging.getLogger(__name__) +logger.addHandler(logging.NullHandler()) + + +@dataclass +class OutputContext: + """Context containing parameters needed for finalizing quantum function output.""" + + cpy_tape: any + classical_values: any + classical_return_indices: any + out_tree_expected: any + snapshots: any + shot_vector: any + num_mcm: int + + +def _resolve_mcm_config(mcm_config, shots): + """Helper function for resolving and validating that the mcm_config is valid for executing.""" + updated_values = {} + + updated_values["postselect_mode"] = ( + None if isinstance(shots, int) and shots == 0 else mcm_config.postselect_mode + ) + if mcm_config.mcm_method is None: + updated_values["mcm_method"] = "one-shot" + if mcm_config.mcm_method == "deferred": + raise ValueError("mcm_method='deferred' is not supported with Catalyst.") + if ( + mcm_config.mcm_method == "single-branch-statistics" + and mcm_config.postselect_mode == "hw-like" + ): + raise ValueError( + "Cannot use postselect_mode='hw-like' with Catalyst when mcm_method != 'one-shot'." + ) + if mcm_config.mcm_method == "one-shot" and shots == 0: + raise ValueError( + "Cannot use the 'one-shot' method for mid-circuit measurements with analytic mode." + ) -transform_prim = _create_transform_primitive() + return replace(mcm_config, **updated_values) -def _get_device_kwargs(device) -> dict: - """Calulcate the params for a device equation.""" - info = extract_backend_info(device) - # Note that the value of rtd_kwargs is a string version of - # the info kwargs, not the info kwargs itself - # this is due to ease of serialization to MLIR - return { - "rtd_kwargs": str(info.kwargs), - "rtd_lib": info.lpath, - "rtd_name": info.c_interface_name, - } +def _get_total_shots(qnode): + """ + Extract total shots from qnode. + If shots is None on the qnode, this method returns 0 (static). + This method allows the qnode shots to be either static (python int + literals) or dynamic (tracers). + """ + # due to possibility of tracer, we cannot use a simple `or` here to simplify + shots_value = qnode._shots.total_shots # pylint: disable=protected-access + if shots_value is None: + shots = 0 + else: + shots = shots_value + return shots + + +def _is_one_shot_compatible_device(qnode): + device_name = qnode.device.name + exclude_devices = {"softwareq.qpp", "nvidia.custatevec", "nvidia.cutensornet"} + + # Check device name against exclude list + if device_name in exclude_devices: + return False + + # Additional check for OQDDevice class + device_class_name = qnode.device.__class__.__name__ + return device_class_name != "OQDDevice" + + +def configure_mcm_and_try_one_shot(qnode, args, kwargs): + """Configure mid-circuit measurement settings and handle one-shot execution.""" + dynamic_one_shot_called = getattr(qnode, "_dynamic_one_shot_called", False) + if not dynamic_one_shot_called: + mcm_config = copy( + qml.devices.MCMConfig( + postselect_mode=qnode.execute_kwargs["postselect_mode"], + mcm_method=qnode.execute_kwargs["mcm_method"], + ) + ) + total_shots = _get_total_shots(qnode) + user_specified_mcm_method = mcm_config.mcm_method + mcm_config = _resolve_mcm_config(mcm_config, total_shots) + + # Check if measurements_from_{samples/counts} is being used + uses_measurements_from_samples = uses_transform(qnode, "measurements_from_samples") + uses_measurements_from_counts = uses_transform(qnode, "measurements_from_counts") + has_finite_shots = isinstance(total_shots, int) and total_shots > 0 + + # For cases that user are not tend to executed with one-shot, and facing + # 1. non-one-shot compatible device, + # 2. non-finite shots, + # 3. measurement transform, + # fallback to single-branch-statistics + one_shot_compatible = _is_one_shot_compatible_device(qnode) + one_shot_compatible &= has_finite_shots + one_shot_compatible &= not uses_measurements_from_samples + one_shot_compatible &= not uses_measurements_from_counts + + should_fallback = ( + not one_shot_compatible + and user_specified_mcm_method is None + and mcm_config.mcm_method == "one-shot" + ) + + if should_fallback: + mcm_config = replace(mcm_config, mcm_method="single-branch-statistics") + if mcm_config.mcm_method == "one-shot": + # If measurements_from_samples/counts while one-shot is used, raise an error + if uses_measurements_from_samples: + raise CompileError("measurements_from_samples is not supported with one-shot") + if uses_measurements_from_counts: + raise CompileError("measurements_from_counts is not supported with one-shot") -# code example has long lines -# pylint: disable=line-too-long -def from_plxpr(plxpr: ClosedJaxpr) -> Callable[..., Jaxpr]: - """Convert PennyLane variant jaxpr to Catalyst variant jaxpr. + mcm_config = replace( + mcm_config, postselect_mode=mcm_config.postselect_mode or "hw-like" + ) + try: + return Function(dynamic_one_shot(qnode, mcm_config=mcm_config))(*args, **kwargs) + except (TypeError, ValueError, CompileError, NotImplementedError) as e: + # If user specified mcm_method, we can't fallback to single-branch-statistics, + # reraise the original error + if user_specified_mcm_method is not None: + raise + + # Fallback only if mcm was auto-determined + error_msg = str(e) + unsupported_measurement_error = any( + pattern in error_msg + for pattern in [ + "Native mid-circuit measurement mode does not support", + "qml.var(obs) cannot be returned when `mcm_method='one-shot'`", + "empty wires is not supported with dynamic wires in one-shot mode", + "No need to run one-shot mode", + ] + ) + + # Fallback if error is related to unsupported measurements + if unsupported_measurement_error: + logger.warning("Fallback to single-branch-statistics: %s", e) + mcm_config = replace(mcm_config, mcm_method="single-branch-statistics") + else: + raise + return None + + +def _reconstruct_output_with_classical_values( + measurement_results, classical_values, classical_return_indices +): + """ + Reconstruct the output values from the classical values and measurement results. Args: - jaxpr (ClosedJaxpr): PennyLane variant jaxpr - + out: Output from measurement processing + classical_values: Classical values + classical_return_indices: Indices of classical values Returns: - Callable: A function that accepts the same arguments as the plxpr and returns catalyst - variant jaxpr. + results: Reconstructed output with classical values inserted + """ + if not classical_values: + return measurement_results - Note that the input jaxpr should be workflow level and contain qnode primitives, rather than - qfunc level with individual operators. + total_expected = len(classical_values) + len(measurement_results) + classical_iter = iter(classical_values) + measurement_iter = iter(measurement_results) - .. code-block:: python + def get_next_value(idx): + return next(classical_iter) if idx in classical_return_indices else next(measurement_iter) + + results = [get_next_value(i) for i in range(total_expected)] + return results - from catalyst.from_plxpr import from_plxpr - - qml.capture.enable() - - @qml.qnode(qml.device('lightning.qubit', wires=2)) - def circuit(x): - qml.RX(x, 0) - return qml.probs(wires=(0, 1)) - - def f(x): - return circuit(2 * x) ** 2 - - plxpr = jax.make_jaxpr(circuit)(0.5) - - print(from_plxpr(plxpr)(0.5)) - - .. code-block:: none - - { lambda ; a:f64[]. let - b:f64[4] = func[ - call_jaxpr={ lambda ; c:f64[]. let - device_init[ - rtd_kwargs={'shots': 0, 'mcmc': False, 'num_burnin': 0, 'kernel_name': None} - rtd_lib=*** - rtd_name=LightningSimulator - ] - d:AbstractQreg() = qalloc 2 - e:AbstractQbit() = qextract d 0 - f:AbstractQbit() = qinst[ - adjoint=False - ctrl_len=0 - op=RX - params_len=1 - qubits_len=1 - ] e c - g:AbstractQbit() = qextract d 1 - h:AbstractObs(num_qubits=2,primitive=compbasis) = compbasis f g - i:f64[4] = probs[shape=(4,) shots=None] h - j:AbstractQreg() = qinsert d 0 f - qdealloc j - in (i,) } - qnode= - ] a - in (b,) } +def _extract_classical_and_measurement_results(results, classical_return_indices): """ - return jax.make_jaxpr(partial(WorkflowInterpreter().eval, plxpr.jaxpr, plxpr.consts)) + Split results into classical values and measurement results. + It assume that the results are in the order of classical values and measurement results. + """ + num_classical_return_indices = len(classical_return_indices) + classical_values = results[:num_classical_return_indices] + measurement_results = results[num_classical_return_indices:] + return classical_values, measurement_results -class WorkflowInterpreter(PlxprInterpreter): - """An interpreter that converts a qnode primitive from a plxpr variant to a catalyst jaxpr variant.""" +def _finalize_output(out, ctx: OutputContext): + """ + Finalize the output by reconstructing with classical values and unflattening to the + expected tree structure. + Args: + out: The output to finalize + context: OutputContext containing all necessary parameters for finalization + """ + # Handle case with no measurements + if len(ctx.cpy_tape.measurements) == 0: + out = out[: -ctx.num_mcm] - def __init__(self): - self._pass_pipeline = qml.transforms.core.TransformProgram() - self.init_qreg = None + out = _reconstruct_output_with_classical_values( + out, ctx.classical_values, ctx.classical_return_indices + ) - # Compiler options for the new decomposition system - self.requires_decompose_lowering = False - self.decompose_tkwargs = {} # target gateset + out_tree_expected = ctx.out_tree_expected + if ctx.snapshots is not None: + out = (out[0], tree_unflatten(out_tree_expected[1], out[1])) + else: + out = tree_unflatten(out_tree_expected[0], out) + return out - super().__init__() +class QFunc: + """A device specific quantum function. -# pylint: disable=unused-argument, too-many-arguments -@WorkflowInterpreter.register_primitive(qnode_prim) -def handle_qnode( - self, *args, qnode, device, shots_len, execution_config, qfunc_jaxpr, n_consts, batch_dims=None -): - """Handle the conversion from plxpr to Catalyst jaxpr for the qnode primitive""" + Args: + qfunc (Callable): the quantum function + shots (int): How many times the circuit should be evaluated (or sampled) to estimate + the expectation values + device (a derived class from QubitDevice): a device specification which determines + the valid gate set for the quantum function + """ - self.qubit_index_recorder = QubitIndexRecorder() + def __new__(cls): + raise NotImplementedError() # pragma: no-cover - if shots_len > 1: - raise NotImplementedError("shot vectors are not yet supported for catalyst conversion.") + # pylint: disable=no-member + # pylint: disable=self-cls-assignment + @debug_logger + def __call__(self, *args, **kwargs): - shots = args[0] if shots_len else 0 - consts = args[shots_len : n_consts + shots_len] - non_const_args = args[shots_len + n_consts :] + if EvaluationContext.is_quantum_tracing(): + raise CompileError("Can't nest qnodes under qjit") - closed_jaxpr = ( - ClosedJaxpr(qfunc_jaxpr, consts) - if not self.requires_decompose_lowering - else _apply_compiler_decompose_to_plxpr( - inner_jaxpr=qfunc_jaxpr, - consts=consts, - ncargs=non_const_args, - tgateset=list(self.decompose_tkwargs.get("gate_set", [])), - ) - ) + assert isinstance(self, qml.QNode) - graph_succeeded = False - if self.requires_decompose_lowering: - closed_jaxpr, graph_succeeded = _collect_and_compile_graph_solutions( - inner_jaxpr=closed_jaxpr.jaxpr, - consts=closed_jaxpr.consts, - tkwargs=self.decompose_tkwargs, - ncargs=non_const_args, - ) + new_transform_program, new_pipeline = _extract_passes(self.transform_program) - # Fallback to the legacy decomposition if the graph-based decomposition failed - if not graph_succeeded: - # Remove the decompose-lowering pass from the pipeline - self._pass_pipeline = [p for p in self._pass_pipeline if p.name != "decompose-lowering"] - closed_jaxpr = _apply_compiler_decompose_to_plxpr( - inner_jaxpr=closed_jaxpr.jaxpr, - consts=closed_jaxpr.consts, - ncargs=non_const_args, - tkwargs=self.decompose_tkwargs, - ) + # Update the qnode with peephole pipeline + pass_pipeline = kwargs.pop("pass_pipeline", ()) or () + pass_pipeline += new_pipeline + pass_pipeline = dictionary_to_list_of_passes(pass_pipeline) + new_qnode = copy(self) + new_qnode._transform_program = new_transform_program # pylint: disable=protected-access + + # Mid-circuit measurement configuration/execution + fn_result = configure_mcm_and_try_one_shot(new_qnode, args, kwargs) + + # If the qnode is failed to execute as one-shot, fn_result will be None + if fn_result is not None: + return fn_result + + new_device = copy(new_qnode.device) + qjit_device = QJITDevice(new_device) + + static_argnums = kwargs.pop("static_argnums", ()) + out_tree_expected = kwargs.pop("_out_tree_expected", []) + classical_return_indices = kwargs.pop("_classical_return_indices", []) + num_mcm_expected = kwargs.pop("_num_mcm_expected", []) + debug_info = kwargs.pop("debug_info", None) - def calling_convention(*args): - device_init_p.bind( - shots, - auto_qubit_management=(device.wires is None), - **_get_device_kwargs(device), + print(new_qnode.transform_program) + print(pass_pipeline) + + def _eval_quantum(*args, **kwargs): + trace_result = trace_quantum_function( + new_qnode.func, + qjit_device, + args, + kwargs, + new_qnode, + static_argnums, + debug_info, + ) + closed_jaxpr = trace_result.closed_jaxpr + out_type = trace_result.out_type + out_tree = trace_result.out_tree + out_tree_exp = trace_result.return_values_tree + cls_ret_idx = trace_result.classical_return_indices + num_mcm = trace_result.num_mcm + + out_tree_expected.append(out_tree_exp) + classical_return_indices.append(cls_ret_idx) + num_mcm_expected.append(num_mcm) + dynamic_args = filter_static_args(args, static_argnums) + args_expanded = get_implicit_and_explicit_flat_args(None, *dynamic_args, **kwargs) + res_expanded = eval_jaxpr(closed_jaxpr.jaxpr, closed_jaxpr.consts, *args_expanded) + _, out_keep = unzip2(out_type) + res_flat = [r for r, k in zip(res_expanded, out_keep) if k] + return tree_unflatten(out_tree, res_flat) + + flattened_fun, _, _, out_tree_promise = deduce_avals( + _eval_quantum, args, kwargs, static_argnums, debug_info ) - qreg = qalloc_p.bind(len(device.wires)) - self.init_qreg = QubitHandler(qreg, self.qubit_index_recorder) - converter = PLxPRToQuantumJaxprInterpreter( - device, shots, self.init_qreg, {}, self.qubit_index_recorder + dynamic_args = filter_static_args(args, static_argnums) + args_flat = tree_flatten((dynamic_args, kwargs))[0] + res_flat = quantum_kernel_p.bind( + flattened_fun, *args_flat, qnode=self, pipeline=tuple(pass_pipeline) ) - retvals = converter(closed_jaxpr, *args) - self.init_qreg.insert_all_dangling_qubits() - qdealloc_p.bind(self.init_qreg.get()) - device_release_p.bind() - return retvals - - if self.requires_decompose_lowering and graph_succeeded: - # Add gate_set attribute to the quantum kernel primitive - # decompose_gatesets is treated as a queue of gatesets to be used - # but we only support a single gateset for now in from_plxpr - # as supporting multiple gatesets requires an MLIR/C++ graph-decomposition - # implementation. The current Python implementation cannot be mixed - # with other transforms in between. - gateset = [_get_operator_name(op) for op in self.decompose_tkwargs.get("gate_set", [])] - setattr(qnode, "decompose_gatesets", [gateset]) - - return quantum_kernel_p.bind( - wrap_init(calling_convention, debug_info=qfunc_jaxpr.debug_info), - *non_const_args, - qnode=qnode, - pipeline=tuple(self._pass_pipeline), + return tree_unflatten(out_tree_promise(), res_flat)[0] + + +# pylint: disable=protected-access +def _get_shot_vector(qnode): + shot_vector = qnode._shots.shot_vector if qnode._shots else [] + return ( + shot_vector + if len(shot_vector) > 1 or any(copies > 1 for _, copies in shot_vector) + else None ) -require_decomposition_transforms = {pl_merge_amplitude_embedding} +def _get_snapshot_results(mcm_method, tape, out): + """ + Get the snapshot results from the tape. + Args: + tape: The tape to get the snapshot results from. + out: The output of the tape. + Returns: + processed_snapshots: The extracted snapshot results if available; + otherwise, returns the original output. + measurement_results: The corresponding measurement results. + """ + # if no snapshot are present, return None, out + assert mcm_method == "one-shot" + if not any(isinstance(op, qml.Snapshot) for op in tape.operations): + return None, out -# pylint: disable=too-many-arguments -@WorkflowInterpreter.register_primitive(transform_prim) -def handle_transform( - self, - *args, - args_slice, - consts_slice, - inner_jaxpr, - targs_slice, - tkwargs, - transform, -): - """Handle the conversion from plxpr to Catalyst jaxpr for a - PL transform.""" - consts = args[consts_slice] - non_const_args = args[args_slice] - targs = args[targs_slice] - - # If the transform is a decomposition transform - # and the graph-based decomposition is enabled - if ( - hasattr(transform._plxpr_transform, "__name__") - and transform._plxpr_transform.__name__ == "decompose_plxpr_to_plxpr" - and qml.decomposition.enabled_graph() - ): - if not self.requires_decompose_lowering: - self.requires_decompose_lowering = True - else: - raise NotImplementedError( - "Multiple decomposition transforms are not yet supported." - ) + # Snapshots present: out[0] = snapshots, out[1] = measurements + snapshot_results, measurement_results = out + + # Take first shot for each snapshot + processed_snapshots = [ + snapshot[0] if hasattr(snapshot, "shape") and len(snapshot.shape) > 1 else snapshot + for snapshot in snapshot_results + ] + + return processed_snapshots, measurement_results + + +def _reshape_for_shot_vector(mcm_method, result, shot_vector): + assert mcm_method == "one-shot" - # Update the decompose_gateset to be used by the quantum kernel primitive - # TODO: we originally wanted to treat decompose_gateset as a queue of - # gatesets to be used by the decompose-lowering pass at MLIR - # but this requires a C++ implementation of the graph-based decomposition - # which doesn't exist yet. - self.decompose_tkwargs = tkwargs - - # Note. We don't perform the compiler-specific decomposition here - # to be able to support multiple decomposition transforms - # and collect all the required gatesets - # as well as being able to support other transforms in between. - - # The compiler specific transformation will be performed - # in the qnode handler. - - # Add the decompose-lowering pass to the start of the pipeline - container = qml.transforms.core.TransformContainer(qml.transforms.decompose) - self._pass_pipeline.insert_front(container) - # We still need to construct and solve the graph based on - # the current jaxpr based on the current gateset - # but we don't rewrite the jaxpr at this stage. - - # gds_interpreter = DecompRuleInterpreter(*targs, **tkwargs) - - # def gds_wrapper(*args): - # return gds_interpreter.eval(inner_jaxpr, consts, *args) - - # final_jaxpr = jax.make_jaxpr(gds_wrapper)(*args) - # return self.eval(final_jaxpr.jaxpr, consts, *non_const_args) - return self.eval(inner_jaxpr, consts, *non_const_args) - - if transform.pass_name is None: - # Use PL's ExpandTransformsInterpreter to expand this and any embedded - # transform according to PL rules. It works by overriding the primitive - # registration, making all embedded transforms follow the PL rules - # from now on, hence ignoring the Catalyst pass conversion - def wrapper(*args): - return ExpandTransformsInterpreter().eval(inner_jaxpr, consts, *args) - - unravelled_jaxpr = jax.make_jaxpr(wrapper)(*non_const_args) - final_jaxpr = transform._plxpr_transform( - unravelled_jaxpr.jaxpr, unravelled_jaxpr.consts, targs, tkwargs, *non_const_args + # Calculate the shape for reshaping based on shot vector + result_list = [] + start_idx = 0 + for shot, copies in shot_vector: + # Reshape this segment to (copies, shot, n_wires) + segment = result[start_idx : start_idx + shot * copies] + if copies > 1: + segment_shape = (copies, shot, result.shape[-1]) + segment = jnp.reshape(segment, segment_shape) + result_list.extend([segment[i] for i in range(copies)]) + else: + result_list.append(segment) + start_idx += shot * copies + result = tuple(result_list) + return result + + +def _process_terminal_measurements(mcm_method, cpy_tape, out, snapshots, shot_vector): + """Process measurements when there are no mid-circuit measurements.""" + assert mcm_method == "one-shot" + + # flatten the outs structure + out, _ = tree_flatten(out) + new_out = [] + idx = 0 + + for m in cpy_tape.measurements: + if isinstance(m, CountsMP): + if isinstance(out[idx], tuple) and len(out[idx]) == 2: + # CountsMP result is stored as (keys, counts) tuple + keys, counts = out[idx] + idx += 1 + else: + keys = out[idx] + counts = out[idx + 1] + idx += 2 + + if snapshots is not None: + counts_array = jnp.stack(counts, axis=0) + aggregated_counts = jnp.sum(counts_array, axis=0) + counts_result = (keys, aggregated_counts) + else: + aggregated_counts = jnp.sum(counts, axis=0) + counts_result = (keys[0], aggregated_counts) + + new_out.append(counts_result) + continue + + result = jnp.squeeze(out[idx]) + max_ndim = min(len(out[idx].shape), 2) + if out[idx].shape[0] == 1: + # Adding the first axis back when the first axis in the original + # array is 1, since it corresponds to the shot's dimension. + result = jnp.expand_dims(result, axis=0) + if result.ndim == 1 and max_ndim == 2: + result = jnp.expand_dims(result, axis=1) + + # Without MCMs and postselection, all samples are valid for use in MP computation. + is_valid = jnp.full((result.shape[0],), True) + processed_result = gather_non_mcm( + m, result, is_valid, postselect_mode="pad-invalid-samples" ) - if transform in require_decomposition_transforms: - final_jaxpr = pl_decompose._plxpr_transform( - final_jaxpr.jaxpr, final_jaxpr.consts, targs, tkwargs, *non_const_args + # Handle shot vector reshaping for SampleMP + if isinstance(m, SampleMP) and shot_vector is not None: + processed_result = _reshape_for_shot_vector(mcm_method, processed_result, shot_vector) + + new_out.append(processed_result) + idx += 1 + + return (snapshots, tuple(new_out)) if snapshots else tuple(new_out) + + +def _validate_one_shot_measurements( + mcm_config, tape: qml.tape.QuantumTape, user_specified_mcm_method, shot_vector, wires +) -> None: + """Validate measurements for one-shot mode. + + Args: + mcm_config: The mid-circuit measurement configuration + tape: The quantum tape containing measurements to validate + qnode: The quantum node being transformed + + Raises: + TypeError: If unsupported measurement types are used + NotImplementedError: If measurement configuration is not supported + """ + mcm_method = mcm_config.mcm_method + assert mcm_method == "one-shot" + + # Check if using shot vector with non-SampleMP measurements + has_shot_vector = len(shot_vector) > 1 or any(copies > 1 for _, copies in shot_vector) + has_wires = wires is not None and not is_dynamic_wires(wires) + + # Raise an error if there are no mid-circuit measurements, it will fallback to + # single-branch-statistics + if ( + not any(isinstance(op, MidCircuitMeasure) for op in tape.operations) + and user_specified_mcm_method is None + ): + raise ValueError("No need to run one-shot mode when there are no mid-circuit measurements.") + + for m in tape.measurements: + # Check if measurement type is supported + if not isinstance(m, (CountsMP, ExpectationMP, ProbabilityMP, SampleMP, VarianceMP)): + raise TypeError( + f"Native mid-circuit measurement mode does not support {type(m).__name__} " + "measurements." ) - return self.eval(final_jaxpr.jaxpr, final_jaxpr.consts, *non_const_args) + # Check variance with observable + if isinstance(m, VarianceMP) and m.obs: + raise TypeError( + "qml.var(obs) cannot be returned when `mcm_method='one-shot'` because " + "the Catalyst compiler does not support qml.sample(obs)." + ) - # Apply the corresponding Catalyst pass counterpart - container = qml.transforms.core.TransformContainer(transform, args=targs, kwargs=tkwargs) - self._pass_pipeline.insert_front(container) - return self.eval(inner_jaxpr, consts, *non_const_args) + # Check if the measurement is supported with shot-vector + if has_shot_vector and not isinstance(m, SampleMP): + raise NotImplementedError( + f"Measurement {type(m).__name__} does not support shot-vectors. " + "Use qml.sample() instead." + ) + # Check dynamic wires with empty wires + if not has_wires and isinstance(m, (SampleMP, CountsMP)) and (m.wires.tolist() == []): + raise NotImplementedError( + f"Measurement {type(m).__name__} with empty wires is not supported with " + "dynamic wires in one-shot mode. Please specify a constant number of wires on " + "the device." + ) -# pylint: disable=too-many-positional-arguments -def trace_from_pennylane( - fn, static_argnums, dynamic_args, abstracted_axes, sig, kwargs, debug_info=None -): - """Capture the JAX program representation (JAXPR) of the wrapped function, using - PL capure module. +# pylint: disable=protected-access,no-member,not-callable +def dynamic_one_shot(qnode, **kwargs): + """Transform a QNode to into several one-shot tapes to support dynamic circuit execution. Args: - fn(Callable): the user function to be traced - static_argnums(int or Seqence[Int]): an index or a sequence of indices that specifies the - positions of static arguments. - dynamic_args(Seqence[Any]): the abstract values of the dynamic arguments. - abstracted_axes (Sequence[Sequence[str]] or Dict[int, str] or Sequence[Dict[int, str]]): - An experimental option to specify dynamic tensor shapes. - This option affects the compilation of the annotated function. - Function arguments with ``abstracted_axes`` specified will be compiled to ranked tensors - with dynamic shapes. For more details, please see the Dynamically-shaped Arrays section - below. - sig(Sequence[Any]): a tuple indicating the argument signature of the function. Static arguments - are indicated with their literal values, and dynamic arguments are indicated by abstract - values. - kwargs(Dict[str, Any]): keyword argumemts to the function. - debug_info(jax.api_util.debug_info): a source debug information object required by jaxprs. + qnode (QNode): a quantum circuit which will run ``num_shots`` times Returns: - ClosedJaxpr: captured JAXPR - Tuple[Tuple[ShapedArray, bool]]: the return type of the captured JAXPR. - The boolean indicates whether each result is a value returned by the user function. - PyTreeDef: PyTree metadata of the function output - Tuple[Any]: the dynamic argument signature - """ + qnode (QNode): - with transient_jax_config({"jax_dynamic_shapes": True}): + The transformed circuit to be run ``num_shots`` times such as to simulate dynamic execution. - make_jaxpr_kwargs = { - "static_argnums": static_argnums, - "abstracted_axes": abstracted_axes, - "debug_info": debug_info, - } - args = sig + **Example** - if isinstance(fn, qml.QNode) and static_argnums: - # `make_jaxpr2` sees the qnode - # The static_argnum on the wrapped function takes precedence over the - # one in `make_jaxpr` - # https://github.com/jax-ml/jax/blob/636691bba40b936b8b64a4792c1d2158296e9dd4/jax/_src/linear_util.py#L231 - # Therefore we need to coordinate them manually - fn.static_argnums = static_argnums + Consider the following circuit: - plxpr, out_type, out_treedef = make_jaxpr2(fn, **make_jaxpr_kwargs)(*args, **kwargs) - jaxpr = from_plxpr(plxpr)(*dynamic_args, **kwargs) + .. code-block:: python - return jaxpr, out_type, out_treedef, sig + dev = qml.device("lightning.qubit", shots=100) + params = np.pi / 4 * np.ones(2) + @qjit + @dynamic_one_shot + @qml.qnode(dev, diff_method=None) + def circuit(x, y): + qml.RX(x, wires=0) + m0 = measure(0, reset=reset, postselect=postselect) -def _apply_compiler_decompose_to_plxpr(inner_jaxpr, consts, ncargs, tgateset=None, tkwargs=None): - """Apply the compiler-specific decomposition for a given JAXPR. + @cond(m0 == 1) + def ansatz(): + qml.RY(y, wires=1) - This function first disables the graph-based decomposition optimization - to ensure that only high-level gates and templates with a single decomposition - are decomposed. It then performs the pre-mlir decomposition using PennyLane's - `plxpr_transform` function. + ansatz() + return measure_f(wires=[0, 1]) - `tgateset` is a list of target gateset for decomposition. - If provided, it will be combined with the default compiler ops for decomposition. - If not provided, `tkwargs` will be used as the keyword arguments for the - decomposition transform. This is to ensure compatibility with the existing - PennyLane decomposition transform as well as providing a fallback mechanism. + The ``dynamic_one_shot`` decorator prompts the QNode to perform a hundred one-shot + calculations, where in each calculation the ``measure`` operations dynamically + measures the 0-wire and collapse the state vector stochastically. + """ - Args: - inner_jaxpr (Jaxpr): The input JAXPR to be decomposed. - consts (list): The constants used in the JAXPR. - ncargs (list): Non-constant arguments for the JAXPR. - tgateset (list): A list of target gateset for decomposition. Defaults to None. - tkwargs (list): The keyword arguments of the decompose transform. Defaults to None. + cpy_tape = None + mcm_config = kwargs.pop("mcm_config", None) - Returns: - ClosedJaxpr: The decomposed JAXPR. - """ + def transform_to_single_shot(qnode): + if not qnode._shots: + raise exceptions.QuantumFunctionError( + "dynamic_one_shot is only supported with finite shots." + ) - # Disable the graph decomposition optimization - - # Why? Because for the compiler-specific decomposition we want to - # only decompose higher-level gates and templates that only have - # a single decomposition, and not do any further optimization - # based on the graph solution. - # Besides, the graph-based decomposition is not supported - # yet in from_plxpr for most gates and templates. - # TODO: Enable the graph-based decomposition - qml.decomposition.disable_graph() - - kwargs = ( - {"gate_set": set(COMPILER_OPS_FOR_DECOMPOSITION.keys()).union(tgateset)} - if tgateset - else tkwargs - ) - final_jaxpr = qml.transforms.decompose.plxpr_transform(inner_jaxpr, consts, (), kwargs, *ncargs) + user_specified_mcm_method = qnode.execute_kwargs["mcm_method"] + shot_vector = qnode._shots.shot_vector if qnode._shots else [] + wires = qnode.device.wires - qml.decomposition.enable_graph() + @qml.transform + def dynamic_one_shot_partial( + tape: qml.tape.QuantumTape, + ) -> tuple[Sequence[qml.tape.QuantumTape], Callable]: + nonlocal cpy_tape + cpy_tape = tape - return final_jaxpr + _validate_one_shot_measurements( + mcm_config, tape, user_specified_mcm_method, shot_vector, wires + ) + if tape.batch_size is not None: + raise ValueError("mcm_method='one-shot' is not compatible with broadcasting") -def _collect_and_compile_graph_solutions(inner_jaxpr, consts, tkwargs, ncargs): - """Collect and compile graph solutions for a given JAXPR. + aux_tapes = [init_auxiliary_tape(tape)] - This function uses the DecompRuleInterpreter to evaluate - the input JAXPR and obtain a new JAXPR that incorporates - the graph-based decomposition solutions. + def processing_fn(results): + return results - This function doesn't modify the underlying quantum function - but rather constructs a new JAXPR with decomposition rules. + return aux_tapes, processing_fn - Args: - inner_jaxpr (Jaxpr): The input JAXPR to be decomposed. - consts (list): The constants used in the JAXPR. - tkwargs (list): The keyword arguments of the decompose transform. - ncargs (list): Non-constant arguments for the JAXPR. + return dynamic_one_shot_partial(qnode) - Returns: - ClosedJaxpr: The decomposed JAXPR. - bool: A flag indicating whether the graph-based decomposition was successful. - """ - gds_interpreter = DecompRuleInterpreter(**tkwargs) - - def gds_wrapper(*args): - return gds_interpreter.eval(inner_jaxpr, consts, *args) - - graph_succeeded = True - - with warnings.catch_warnings(record=True) as captured_warnings: - warnings.simplefilter("always", UserWarning) - final_jaxpr = jax.make_jaxpr(gds_wrapper)(*ncargs) - - for w in captured_warnings: - warnings.showwarning(w.message, w.category, w.filename, w.lineno) - # TODO: use a custom warning class for this in PennyLane to remove this - # string matching and make it more robust. - if "The graph-based decomposition system is unable" in str(w.message): # pragma: no cover - graph_succeeded = False - warnings.warn( - "Falling back to the legacy decomposition system.", - UserWarning, + single_shot_qnode = transform_to_single_shot(qnode) + single_shot_qnode = qml.set_shots(single_shot_qnode, shots=1) + if mcm_config is not None: + single_shot_qnode.execute_kwargs["postselect_mode"] = mcm_config.postselect_mode + single_shot_qnode.execute_kwargs["mcm_method"] = mcm_config.mcm_method + single_shot_qnode._dynamic_one_shot_called = True + total_shots = _get_total_shots(qnode) + + def one_shot_wrapper(*args, **kwargs): + def wrap_single_shot_qnode(*_): + return single_shot_qnode(*args, **kwargs) + + arg_vmap = jnp.empty((total_shots,), dtype=float) + results = catalyst.vmap(wrap_single_shot_qnode)(arg_vmap) + if isinstance(results[0], tuple) and len(results) == 1: + results = results[0] + has_mcm = any(isinstance(op, MidCircuitMeasure) for op in cpy_tape.operations) + + classical_return_indices = kwargs.pop("_classical_return_indices", [[]])[0] + num_mcm = kwargs.pop("_num_mcm_expected", [0])[0] + out_tree_expected = kwargs.pop("_out_tree_expected", [[]]) + + # Split results into classical and measurement parts + classical_values, results = _extract_classical_and_measurement_results( + results, classical_return_indices + ) + + out = list(results) + + shot_vector = _get_shot_vector(qnode) + snapshots, out = _get_snapshot_results(mcm_config.mcm_method, cpy_tape, out) + + if has_mcm and len(cpy_tape.measurements) > 0: + out = parse_native_mid_circuit_measurements( + cpy_tape, results=results, postselect_mode="pad-invalid-samples" + ) + if len(cpy_tape.measurements) == 1: + out = (out,) + elif len(cpy_tape.measurements) > 0: + out = _process_terminal_measurements( + mcm_config.mcm_method, cpy_tape, out, snapshots, shot_vector ) - return final_jaxpr, graph_succeeded + ctx = OutputContext( + cpy_tape=cpy_tape, + classical_values=classical_values, + classical_return_indices=classical_return_indices, + out_tree_expected=out_tree_expected, + snapshots=snapshots, + shot_vector=shot_vector, + num_mcm=num_mcm, + ) + return _finalize_output(out, ctx) -def _get_operator_name(op): - """Get the name of a pennylane operator, handling wrapped operators. + return one_shot_wrapper - Note: Controlled and Adjoint ops aren't supported in `gate_set` - by PennyLane's DecompositionGraph; unit tests were added in PennyLane. - """ - if isinstance(op, str): - return op - # Return NoNameOp if the operator has no _primitive.name attribute. - # This is to avoid errors when we capture the program - # as we deal with such ops later in the decomposition graph. - return getattr(op._primitive, "name", "NoNameOp") +def _extract_passes(transform_program): + tape_transforms = [] + pass_pipeline = [] + for t in transform_program: + if t.pass_name: + pass_pipeline.append(Pass(t.pass_name, *t.args, **t.kwargs)) + else: + tape_transforms.append(t) + return qml.transforms.core.TransformProgram(tape_transforms), tuple(pass_pipeline) \ No newline at end of file diff --git a/frontend/catalyst/qfunc.py b/frontend/catalyst/qfunc.py index edac9890a7..fab0d2e090 100644 --- a/frontend/catalyst/qfunc.py +++ b/frontend/catalyst/qfunc.py @@ -43,7 +43,7 @@ from catalyst.jax_primitives import quantum_kernel_p from catalyst.jax_tracer import Function, trace_quantum_function from catalyst.logging import debug_logger -from catalyst.passes.pass_api import dictionary_to_list_of_passes +from catalyst.passes.pass_api import dictionary_to_list_of_passes, Pass from catalyst.tracing.contexts import EvaluationContext from catalyst.tracing.type_signatures import filter_static_args from catalyst.utils.exceptions import CompileError @@ -283,18 +283,22 @@ def __call__(self, *args, **kwargs): assert isinstance(self, qml.QNode) + new_transform_program, new_pipeline = _extract_passes(self.transform_program) + # Update the qnode with peephole pipeline - pass_pipeline = kwargs.pop("pass_pipeline", []) + pass_pipeline = kwargs.pop("pass_pipeline", []) + new_pipeline pass_pipeline = dictionary_to_list_of_passes(pass_pipeline) + new_qnode = copy(self) + new_qnode._transform_program = new_transform_program # pylint: disable=protected-access # Mid-circuit measurement configuration/execution - fn_result = configure_mcm_and_try_one_shot(self, args, kwargs) + fn_result = configure_mcm_and_try_one_shot(new_qnode, args, kwargs) # If the qnode is failed to execute as one-shot, fn_result will be None if fn_result is not None: return fn_result - new_device = copy(self.device) + new_device = copy(new_qnode.device) qjit_device = QJITDevice(new_device) static_argnums = kwargs.pop("static_argnums", ()) @@ -305,11 +309,11 @@ def __call__(self, *args, **kwargs): def _eval_quantum(*args, **kwargs): trace_result = trace_quantum_function( - self.func, + new_qnode.func, qjit_device, args, kwargs, - self, + new_qnode, static_argnums, debug_info, ) @@ -649,3 +653,14 @@ def wrap_single_shot_qnode(*_): return _finalize_output(out, ctx) return one_shot_wrapper + + +def _extract_passes(transform_program): + tape_transforms = [] + pass_pipeline = [] + for t in transform_program: + if t.pass_name: + pass_pipeline.append(Pass(t.pass_name, *t.args, **t.kwargs)) + else: + tape_transforms.append(t) + return qml.transforms.core.TransformProgram(tape_transforms), tuple(pass_pipeline) \ No newline at end of file From 0cb9476f6535cc88e277a44ce66caf1aec4bd615 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Thu, 13 Nov 2025 12:25:41 -0500 Subject: [PATCH 04/24] messed from plxpr up somehow --- frontend/catalyst/from_plxpr/__init__.py | 2 +- frontend/catalyst/from_plxpr/control_flow.py | 150 ++- frontend/catalyst/from_plxpr/decompose.py | 9 +- frontend/catalyst/from_plxpr/from_plxpr.py | 1011 +++++++---------- .../catalyst/from_plxpr/qfunc_interpreter.py | 185 ++- frontend/catalyst/from_plxpr/qubit_handler.py | 42 +- 6 files changed, 720 insertions(+), 679 deletions(-) diff --git a/frontend/catalyst/from_plxpr/__init__.py b/frontend/catalyst/from_plxpr/__init__.py index 3599025f6e..a39039fe1d 100644 --- a/frontend/catalyst/from_plxpr/__init__.py +++ b/frontend/catalyst/from_plxpr/__init__.py @@ -15,4 +15,4 @@ """Conversion from plxpr to catalyst jaxpr""" from catalyst.from_plxpr.control_flow import handle_cond, handle_for_loop, handle_while_loop -from catalyst.from_plxpr.from_plxpr import from_plxpr, trace_from_pennylane +from catalyst.from_plxpr.from_plxpr import from_plxpr, register_transform, trace_from_pennylane diff --git a/frontend/catalyst/from_plxpr/control_flow.py b/frontend/catalyst/from_plxpr/control_flow.py index 29a27998a8..a538bc1fab 100644 --- a/frontend/catalyst/from_plxpr/control_flow.py +++ b/frontend/catalyst/from_plxpr/control_flow.py @@ -26,24 +26,70 @@ from pennylane.capture.primitives import while_loop_prim as plxpr_while_loop_prim from catalyst.from_plxpr.from_plxpr import PLxPRToQuantumJaxprInterpreter, WorkflowInterpreter -from catalyst.from_plxpr.qubit_handler import QubitHandler, QubitIndexRecorder +from catalyst.from_plxpr.qubit_handler import ( + QubitHandler, + QubitIndexRecorder, + _get_dynamically_allocated_qregs, +) from catalyst.jax_extras import jaxpr_pad_consts from catalyst.jax_primitives import cond_p, for_p, while_p -def _calling_convention(interpreter, closed_jaxpr, *args_plus_qreg): - # The last arg is the scope argument for the body jaxpr - *args, qreg = args_plus_qreg +def _calling_convention( + interpreter, closed_jaxpr, *args_plus_qregs, outer_dynqreg_handlers=(), return_qreg=True +): + # Arg structure (all args are tracers, since this function is to be `make_jaxpr`'d): + # Regular args, then dynamically allocated qregs, then global qreg + # TODO: merge dynamically allocaed qregs into regular args? + # But this is tricky, since qreg arguments need all the SSA value semantics conversion infra + # and are different from the regular plain arguments. + *args_plus_dynqregs, global_qreg = args_plus_qregs + num_dynamic_alloced_qregs = len(outer_dynqreg_handlers) + args, dynalloced_qregs = ( + args_plus_dynqregs[: len(args_plus_dynqregs) - num_dynamic_alloced_qregs], + args_plus_dynqregs[len(args_plus_dynqregs) - num_dynamic_alloced_qregs :], + ) # Launch a new interpreter for the body region # A new interpreter's root qreg value needs a new recorder converter = copy(interpreter) converter.qubit_index_recorder = QubitIndexRecorder() - init_qreg = QubitHandler(qreg, converter.qubit_index_recorder) + init_qreg = QubitHandler(global_qreg, converter.qubit_index_recorder) converter.init_qreg = init_qreg + # add dynamic qregs to recorder + qreg_map = {} + dyn_qreg_handlers = [] + for dyn_qreg, outer_dynqreg_handler in zip( + dynalloced_qregs, outer_dynqreg_handlers, strict=True + ): + dyn_qreg_handler = QubitHandler(dyn_qreg, converter.qubit_index_recorder) + dyn_qreg_handlers.append(dyn_qreg_handler) + + # plxpr global wire index does not change across scopes + # So scope arg dynamic qregs need to have the same root hash as their corresponding + # qreg tracers outside + dyn_qreg_handler.root_hash = outer_dynqreg_handler.root_hash + + # Each qreg argument of the subscope corresponds to a qreg from the outer scope + qreg_map[outer_dynqreg_handler] = dyn_qreg_handler + + # The new interpreter's recorder needs to be updated to include the qreg args + # of this scope, instead of the outer qregs + if qreg_map: + for k, outer_dynqreg_handler in interpreter.qubit_index_recorder.map.items(): + converter.qubit_index_recorder[k] = qreg_map[outer_dynqreg_handler] + retvals = converter(closed_jaxpr, *args) + if not return_qreg: + return retvals + init_qreg.insert_all_dangling_qubits() + + # Return all registers + for dyn_qreg_handler in dyn_qreg_handlers: + dyn_qreg_handler.insert_all_dangling_qubits() + retvals.append(dyn_qreg_handler.get()) return *retvals, converter.init_qreg.get() @@ -89,7 +135,18 @@ def handle_cond(self, *plxpr_invals, jaxpr_branches, consts_slices, args_slice): """Handle the conversion from plxpr to Catalyst jaxpr for the cond primitive""" args = plxpr_invals[args_slice] self.init_qreg.insert_all_dangling_qubits() - args_plus_qreg = [*args, self.init_qreg.get()] # Add the qreg to the args + + dynalloced_qregs, dynalloced_wire_global_indices = _get_dynamically_allocated_qregs( + plxpr_invals, self.qubit_index_recorder, self.init_qreg + ) + + # Add the qregs to the args + args_plus_qreg = [ + *args, + *[dyn_qreg.get() for dyn_qreg in dynalloced_qregs], + self.init_qreg.get(), + ] + converted_jaxpr_branches = [] all_consts = [] @@ -102,7 +159,9 @@ def handle_cond(self, *plxpr_invals, jaxpr_branches, consts_slices, args_slice): converted_jaxpr_branch = None closed_jaxpr = ClosedJaxpr(plxpr_branch, branch_consts) - f = partial(_calling_convention, self, closed_jaxpr) + f = partial( + _calling_convention, self, closed_jaxpr, outer_dynqreg_handlers=dynalloced_qregs + ) converted_jaxpr_branch = jax.make_jaxpr(f)(*args_plus_qreg) all_consts += converted_jaxpr_branch.consts @@ -111,6 +170,8 @@ def handle_cond(self, *plxpr_invals, jaxpr_branches, consts_slices, args_slice): predicate = [_to_bool_if_not(p) for p in plxpr_invals[: len(jaxpr_branches) - 1]] # Build Catalyst compatible input values + # strip global wire indices of dynamic wires + all_consts = tuple(const for const in all_consts if const not in dynalloced_wire_global_indices) cond_invals = [*predicate, *all_consts, *args_plus_qreg] # Perform the binding @@ -120,9 +181,12 @@ def handle_cond(self, *plxpr_invals, jaxpr_branches, consts_slices, args_slice): nimplicit_outputs=None, ) - # We assume the last output value is the returned qreg. + # Output structure: + # First a list of dynamically allocated qregs, then the global qreg # Update the current qreg and remove it from the output values. self.init_qreg.set(outvals.pop()) + for dyn_qreg in reversed(dynalloced_qregs): + dyn_qreg.set(outvals.pop()) # Return only the output values that match the plxpr output values return outvals @@ -192,9 +256,15 @@ def handle_for_loop( # Add the iteration start and the qreg to the args self.init_qreg.insert_all_dangling_qubits() + + dynalloced_qregs, dynalloced_wire_global_indices = _get_dynamically_allocated_qregs( + plxpr_invals, self.qubit_index_recorder, self.init_qreg + ) + start_plus_args_plus_qreg = [ start, *args, + *[dyn_qreg.get() for dyn_qreg in dynalloced_qregs], self.init_qreg.get(), ] @@ -202,7 +272,12 @@ def handle_for_loop( jaxpr = ClosedJaxpr(jaxpr_body_fn, consts) - f = partial(_calling_convention, self, jaxpr) + f = partial( + _calling_convention, + self, + jaxpr, + outer_dynqreg_handlers=dynalloced_qregs, + ) converted_jaxpr_branch = jax.make_jaxpr(f)(*start_plus_args_plus_qreg) converted_closed_jaxpr_branch = ClosedJaxpr( @@ -210,7 +285,9 @@ def handle_for_loop( ) # Build Catalyst compatible input values + # strip global wire indices of dynamic wires new_consts = converted_jaxpr_branch.consts + new_consts = tuple(const for const in new_consts if const not in dynalloced_wire_global_indices) for_loop_invals = [*new_consts, start, stop, step, *start_plus_args_plus_qreg] # Config additional for loop settings @@ -226,10 +303,14 @@ def handle_for_loop( preserve_dimensions=True, ) - # We assume the last output value is the returned qreg. + # Output structure: + # First a list of dynamically allocated qregs, then the global qreg # Update the current qreg and remove it from the output values. self.init_qreg.set(outvals.pop()) + for dyn_qreg in reversed(dynalloced_qregs): + dyn_qreg.set(outvals.pop()) + # Return only the output values that match the plxpr output values return outvals @@ -288,57 +369,59 @@ def handle_while_loop( ): """Handle the conversion from plxpr to Catalyst jaxpr for the while loop primitive""" self.init_qreg.insert_all_dangling_qubits() + dynalloced_qregs, dynalloced_wire_global_indices = _get_dynamically_allocated_qregs( + plxpr_invals, self.qubit_index_recorder, self.init_qreg + ) consts_body = plxpr_invals[body_slice] consts_cond = plxpr_invals[cond_slice] args = plxpr_invals[args_slice] - args_plus_qreg = [*args, self.init_qreg.get()] # Add the qreg to the args + args_plus_qreg = [ + *args, + *[dyn_qreg.get() for dyn_qreg in dynalloced_qregs], + self.init_qreg.get(), + ] # Add the qreg to the args jaxpr = ClosedJaxpr(jaxpr_body_fn, consts_body) - f = partial(_calling_convention, self, jaxpr) - converted_body_jaxpr_branch = jax.make_jaxpr(f)(*args_plus_qreg).jaxpr + f = partial(_calling_convention, self, jaxpr, outer_dynqreg_handlers=dynalloced_qregs) + converted_body_jaxpr_branch = jax.make_jaxpr(f)(*args_plus_qreg) + new_consts_body = converted_body_jaxpr_branch.consts converted_body_closed_jaxpr_branch = ClosedJaxpr( - convert_constvars_jaxpr(converted_body_jaxpr_branch), () + convert_constvars_jaxpr(converted_body_jaxpr_branch.jaxpr), () ) # Convert for condition from plxpr to Catalyst jaxpr # We need to be able to handle arbitrary plxpr here. # But we want to be able to create a state where: # * We do not pass the quantum register as an argument. - # So let's just remove the quantum register here at the end - jaxpr = ClosedJaxpr(jaxpr_cond_fn, consts_cond) - def remove_qreg(*args_plus_qreg): - # The last arg is the scope argument for the body jaxpr - *args, qreg = args_plus_qreg - - # Launch a new interpreter for the body region - # A new interpreter's root qreg value needs a new recorder - converter = copy(self) - converter.qubit_index_recorder = QubitIndexRecorder() - init_qreg = QubitHandler(qreg, converter.qubit_index_recorder) - converter.init_qreg = init_qreg + f_remove_qreg = partial( + _calling_convention, self, jaxpr, outer_dynqreg_handlers=dynalloced_qregs, return_qreg=False + ) - return converter(jaxpr, *args) + converted_cond_jaxpr_branch = jax.make_jaxpr(f_remove_qreg)(*args_plus_qreg) - converted_cond_jaxpr_branch = jax.make_jaxpr(remove_qreg)(*args_plus_qreg).jaxpr converted_cond_closed_jaxpr_branch = ClosedJaxpr( - convert_constvars_jaxpr(converted_cond_jaxpr_branch), () + convert_constvars_jaxpr(converted_cond_jaxpr_branch.jaxpr), () ) # Build Catalyst compatible input values - while_loop_invals = [*consts_cond, *consts_body, *args_plus_qreg] + new_consts_cond = converted_cond_jaxpr_branch.consts + new_consts_body = tuple( + const for const in new_consts_body if const not in dynalloced_wire_global_indices + ) + while_loop_invals = [*new_consts_cond, *new_consts_body, *args_plus_qreg] # Perform the binding outvals = while_p.bind( *while_loop_invals, cond_jaxpr=converted_cond_closed_jaxpr_branch, body_jaxpr=converted_body_closed_jaxpr_branch, - cond_nconsts=len(consts_cond), - body_nconsts=len(consts_body), + cond_nconsts=len(new_consts_cond), + body_nconsts=len(new_consts_body), nimplicit=0, preserve_dimensions=True, ) @@ -347,5 +430,8 @@ def remove_qreg(*args_plus_qreg): # Update the current qreg and remove it from the output values. self.init_qreg.set(outvals.pop()) + for dyn_qreg in reversed(dynalloced_qregs): + dyn_qreg.set(outvals.pop()) + # Return only the output values that match the plxpr output values return outvals diff --git a/frontend/catalyst/from_plxpr/decompose.py b/frontend/catalyst/from_plxpr/decompose.py index 58a34cb620..3df0e3a143 100644 --- a/frontend/catalyst/from_plxpr/decompose.py +++ b/frontend/catalyst/from_plxpr/decompose.py @@ -234,7 +234,14 @@ def interpret_measurement(self, measurement: "qml.measurement.MeasurementProcess num_params=num_params, requires_copy=num_wires == -1, ) - else: # pragma: no cover + elif not any( + keyword in getattr(op.op, "name", "") for keyword in ("Adjoint", "Controlled") + ): # pragma: no cover + # Note that the graph-decomposition returns abstracted rules + # for Adjoint and Controlled operations, so we skip them here. + # These abstracted rules cannot be captured and lowered. + # We use MLIR AdjointOp and ControlledOp primitives + # to deal with decomposition of symbolic operations at PLxPR. raise ValueError(f"Could not capture {op} without the number of wires.") data, struct = jax.tree_util.tree_flatten(measurement) diff --git a/frontend/catalyst/from_plxpr/from_plxpr.py b/frontend/catalyst/from_plxpr/from_plxpr.py index 16997f3cf6..86720baf5a 100644 --- a/frontend/catalyst/from_plxpr/from_plxpr.py +++ b/frontend/catalyst/from_plxpr/from_plxpr.py @@ -1,4 +1,4 @@ -# Copyright 2022-2024 Xanadu Quantum Technologies Inc. +# Copyright 2024 Xanadu Quantum Technologies Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -11,660 +11,515 @@ # 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. - """ -This module contains a patch for the upstream qml.QNode behaviour, in particular around -what happens when a QNode object is called during tracing. Mostly this involves bypassing -the default behaviour and replacing it with a function-like "QNode" primitive. +This submodule defines a utility for converting plxpr into Catalyst jaxpr. """ -import logging +# pylint: disable=protected-access + +import warnings from copy import copy -from dataclasses import dataclass, replace -from typing import Callable, Sequence +from functools import partial +from typing import Callable -import jax.numpy as jnp +import jax import pennylane as qml -from jax.core import eval_jaxpr -from jax.tree_util import tree_flatten, tree_unflatten -from pennylane import exceptions -from pennylane.measurements import CountsMP, ExpectationMP, ProbabilityMP, SampleMP, VarianceMP -from pennylane.transforms.dynamic_one_shot import ( - gather_non_mcm, - init_auxiliary_tape, - parse_native_mid_circuit_measurements, +from jax.extend.core import ClosedJaxpr, Jaxpr +from jax.extend.linear_util import wrap_init +from pennylane.capture import PlxprInterpreter, qnode_prim +from pennylane.capture.expand_transforms import ExpandTransformsInterpreter +from pennylane.capture.primitives import jacobian_prim as pl_jac_prim +from pennylane.capture.primitives import transform_prim +from pennylane.ops.functions.map_wires import _map_wires_transform as pl_map_wires +from pennylane.transforms import cancel_inverses as pl_cancel_inverses +from pennylane.transforms import commute_controlled as pl_commute_controlled +from pennylane.transforms import decompose as pl_decompose +from pennylane.transforms import merge_amplitude_embedding as pl_merge_amplitude_embedding +from pennylane.transforms import merge_rotations as pl_merge_rotations +from pennylane.transforms import single_qubit_fusion as pl_single_qubit_fusion +from pennylane.transforms import unitary_to_rot as pl_unitary_to_rot + +from catalyst.device import extract_backend_info +from catalyst.from_plxpr.decompose import COMPILER_OPS_FOR_DECOMPOSITION, DecompRuleInterpreter +from catalyst.jax_extras import make_jaxpr2, transient_jax_config +from catalyst.jax_primitives import ( + device_init_p, + device_release_p, + qalloc_p, + qdealloc_p, + quantum_kernel_p, ) +from catalyst.passes.pass_api import Pass -import catalyst -from catalyst.api_extensions import MidCircuitMeasure -from catalyst.device import QJITDevice -from catalyst.device.qjit_device import is_dynamic_wires -from catalyst.jax_extras import deduce_avals, get_implicit_and_explicit_flat_args, unzip2 -from catalyst.jax_extras.tracing import uses_transform -from catalyst.jax_primitives import quantum_kernel_p -from catalyst.jax_tracer import Function, trace_quantum_function -from catalyst.logging import debug_logger -from catalyst.passes.pass_api import dictionary_to_list_of_passes, Pass -from catalyst.tracing.contexts import EvaluationContext -from catalyst.tracing.type_signatures import filter_static_args -from catalyst.utils.exceptions import CompileError - -logger = logging.getLogger(__name__) -logger.addHandler(logging.NullHandler()) - - -@dataclass -class OutputContext: - """Context containing parameters needed for finalizing quantum function output.""" - - cpy_tape: any - classical_values: any - classical_return_indices: any - out_tree_expected: any - snapshots: any - shot_vector: any - num_mcm: int - - -def _resolve_mcm_config(mcm_config, shots): - """Helper function for resolving and validating that the mcm_config is valid for executing.""" - updated_values = {} - - updated_values["postselect_mode"] = ( - None if isinstance(shots, int) and shots == 0 else mcm_config.postselect_mode - ) - if mcm_config.mcm_method is None: - updated_values["mcm_method"] = "one-shot" - if mcm_config.mcm_method == "deferred": - raise ValueError("mcm_method='deferred' is not supported with Catalyst.") - if ( - mcm_config.mcm_method == "single-branch-statistics" - and mcm_config.postselect_mode == "hw-like" - ): - raise ValueError( - "Cannot use postselect_mode='hw-like' with Catalyst when mcm_method != 'one-shot'." - ) - if mcm_config.mcm_method == "one-shot" and shots == 0: - raise ValueError( - "Cannot use the 'one-shot' method for mid-circuit measurements with analytic mode." - ) +from .qfunc_interpreter import PLxPRToQuantumJaxprInterpreter +from .qubit_handler import ( + QubitHandler, + QubitIndexRecorder, +) - return replace(mcm_config, **updated_values) +def _get_device_kwargs(device) -> dict: + """Calulcate the params for a device equation.""" + info = extract_backend_info(device) + # Note that the value of rtd_kwargs is a string version of + # the info kwargs, not the info kwargs itself + # this is due to ease of serialization to MLIR + return { + "rtd_kwargs": str(info.kwargs), + "rtd_lib": info.lpath, + "rtd_name": info.c_interface_name, + } -def _get_total_shots(qnode): - """ - Extract total shots from qnode. - If shots is None on the qnode, this method returns 0 (static). - This method allows the qnode shots to be either static (python int - literals) or dynamic (tracers). - """ - # due to possibility of tracer, we cannot use a simple `or` here to simplify - shots_value = qnode._shots.total_shots # pylint: disable=protected-access - if shots_value is None: - shots = 0 - else: - shots = shots_value - return shots - - -def _is_one_shot_compatible_device(qnode): - device_name = qnode.device.name - exclude_devices = {"softwareq.qpp", "nvidia.custatevec", "nvidia.cutensornet"} - - # Check device name against exclude list - if device_name in exclude_devices: - return False - - # Additional check for OQDDevice class - device_class_name = qnode.device.__class__.__name__ - return device_class_name != "OQDDevice" - - -def configure_mcm_and_try_one_shot(qnode, args, kwargs): - """Configure mid-circuit measurement settings and handle one-shot execution.""" - dynamic_one_shot_called = getattr(qnode, "_dynamic_one_shot_called", False) - if not dynamic_one_shot_called: - mcm_config = copy( - qml.devices.MCMConfig( - postselect_mode=qnode.execute_kwargs["postselect_mode"], - mcm_method=qnode.execute_kwargs["mcm_method"], - ) - ) - total_shots = _get_total_shots(qnode) - user_specified_mcm_method = mcm_config.mcm_method - mcm_config = _resolve_mcm_config(mcm_config, total_shots) - - # Check if measurements_from_{samples/counts} is being used - uses_measurements_from_samples = uses_transform(qnode, "measurements_from_samples") - uses_measurements_from_counts = uses_transform(qnode, "measurements_from_counts") - has_finite_shots = isinstance(total_shots, int) and total_shots > 0 - - # For cases that user are not tend to executed with one-shot, and facing - # 1. non-one-shot compatible device, - # 2. non-finite shots, - # 3. measurement transform, - # fallback to single-branch-statistics - one_shot_compatible = _is_one_shot_compatible_device(qnode) - one_shot_compatible &= has_finite_shots - one_shot_compatible &= not uses_measurements_from_samples - one_shot_compatible &= not uses_measurements_from_counts - - should_fallback = ( - not one_shot_compatible - and user_specified_mcm_method is None - and mcm_config.mcm_method == "one-shot" - ) - - if should_fallback: - mcm_config = replace(mcm_config, mcm_method="single-branch-statistics") - - if mcm_config.mcm_method == "one-shot": - # If measurements_from_samples/counts while one-shot is used, raise an error - if uses_measurements_from_samples: - raise CompileError("measurements_from_samples is not supported with one-shot") - if uses_measurements_from_counts: - raise CompileError("measurements_from_counts is not supported with one-shot") - mcm_config = replace( - mcm_config, postselect_mode=mcm_config.postselect_mode or "hw-like" - ) +# code example has long lines +# pylint: disable=line-too-long +def from_plxpr(plxpr: ClosedJaxpr) -> Callable[..., Jaxpr]: + """Convert PennyLane variant jaxpr to Catalyst variant jaxpr. - try: - return Function(dynamic_one_shot(qnode, mcm_config=mcm_config))(*args, **kwargs) - except (TypeError, ValueError, CompileError, NotImplementedError) as e: - # If user specified mcm_method, we can't fallback to single-branch-statistics, - # reraise the original error - if user_specified_mcm_method is not None: - raise - - # Fallback only if mcm was auto-determined - error_msg = str(e) - unsupported_measurement_error = any( - pattern in error_msg - for pattern in [ - "Native mid-circuit measurement mode does not support", - "qml.var(obs) cannot be returned when `mcm_method='one-shot'`", - "empty wires is not supported with dynamic wires in one-shot mode", - "No need to run one-shot mode", - ] - ) - - # Fallback if error is related to unsupported measurements - if unsupported_measurement_error: - logger.warning("Fallback to single-branch-statistics: %s", e) - mcm_config = replace(mcm_config, mcm_method="single-branch-statistics") - else: - raise - return None - - -def _reconstruct_output_with_classical_values( - measurement_results, classical_values, classical_return_indices -): - """ - Reconstruct the output values from the classical values and measurement results. Args: - out: Output from measurement processing - classical_values: Classical values - classical_return_indices: Indices of classical values - Returns: - results: Reconstructed output with classical values inserted - """ - if not classical_values: - return measurement_results - - total_expected = len(classical_values) + len(measurement_results) - classical_iter = iter(classical_values) - measurement_iter = iter(measurement_results) + jaxpr (ClosedJaxpr): PennyLane variant jaxpr - def get_next_value(idx): - return next(classical_iter) if idx in classical_return_indices else next(measurement_iter) - - results = [get_next_value(i) for i in range(total_expected)] - return results + Returns: + Callable: A function that accepts the same arguments as the plxpr and returns catalyst + variant jaxpr. + Note that the input jaxpr should be workflow level and contain qnode primitives, rather than + qfunc level with individual operators. -def _extract_classical_and_measurement_results(results, classical_return_indices): - """ - Split results into classical values and measurement results. - It assume that the results are in the order of classical values and measurement results. - """ - num_classical_return_indices = len(classical_return_indices) - classical_values = results[:num_classical_return_indices] - measurement_results = results[num_classical_return_indices:] - return classical_values, measurement_results + .. code-block:: python + from catalyst.from_plxpr import from_plxpr + + qml.capture.enable() + + @qml.qnode(qml.device('lightning.qubit', wires=2)) + def circuit(x): + qml.RX(x, 0) + return qml.probs(wires=(0, 1)) + + def f(x): + return circuit(2 * x) ** 2 + + plxpr = jax.make_jaxpr(circuit)(0.5) + + print(from_plxpr(plxpr)(0.5)) + + .. code-block:: none + + { lambda ; a:f64[]. let + b:f64[4] = func[ + call_jaxpr={ lambda ; c:f64[]. let + device_init[ + rtd_kwargs={'shots': 0, 'mcmc': False, 'num_burnin': 0, 'kernel_name': None} + rtd_lib=*** + rtd_name=LightningSimulator + ] + d:AbstractQreg() = qalloc 2 + e:AbstractQbit() = qextract d 0 + f:AbstractQbit() = qinst[ + adjoint=False + ctrl_len=0 + op=RX + params_len=1 + qubits_len=1 + ] e c + g:AbstractQbit() = qextract d 1 + h:AbstractObs(num_qubits=2,primitive=compbasis) = compbasis f g + i:f64[4] = probs[shape=(4,) shots=None] h + j:AbstractQreg() = qinsert d 0 f + qdealloc j + in (i,) } + qnode= + ] a + in (b,) } -def _finalize_output(out, ctx: OutputContext): - """ - Finalize the output by reconstructing with classical values and unflattening to the - expected tree structure. - Args: - out: The output to finalize - context: OutputContext containing all necessary parameters for finalization """ - # Handle case with no measurements - if len(ctx.cpy_tape.measurements) == 0: - out = out[: -ctx.num_mcm] - - out = _reconstruct_output_with_classical_values( - out, ctx.classical_values, ctx.classical_return_indices - ) + return jax.make_jaxpr(partial(WorkflowInterpreter().eval, plxpr.jaxpr, plxpr.consts)) - out_tree_expected = ctx.out_tree_expected - if ctx.snapshots is not None: - out = (out[0], tree_unflatten(out_tree_expected[1], out[1])) - else: - out = tree_unflatten(out_tree_expected[0], out) - return out +class WorkflowInterpreter(PlxprInterpreter): + """An interpreter that converts a qnode primitive from a plxpr variant to a catalyst jaxpr variant.""" -class QFunc: - """A device specific quantum function. + def __copy__(self): + new_version = WorkflowInterpreter() + new_version._pass_pipeline = copy(self._pass_pipeline) + new_version.init_qreg = self.init_qreg + new_version.requires_decompose_lowering = self.requires_decompose_lowering + new_version.decompose_tkwargs = copy(self.decompose_tkwargs) + return new_version - Args: - qfunc (Callable): the quantum function - shots (int): How many times the circuit should be evaluated (or sampled) to estimate - the expectation values - device (a derived class from QubitDevice): a device specification which determines - the valid gate set for the quantum function - """ - - def __new__(cls): - raise NotImplementedError() # pragma: no-cover + def __init__(self): + self._pass_pipeline = [] + self.init_qreg = None - # pylint: disable=no-member - # pylint: disable=self-cls-assignment - @debug_logger - def __call__(self, *args, **kwargs): + # Compiler options for the new decomposition system + self.requires_decompose_lowering = False + self.decompose_tkwargs = {} # target gateset - if EvaluationContext.is_quantum_tracing(): - raise CompileError("Can't nest qnodes under qjit") + super().__init__() - assert isinstance(self, qml.QNode) - new_transform_program, new_pipeline = _extract_passes(self.transform_program) +@WorkflowInterpreter.register_primitive(pl_jac_prim) +def handle_grad(self, *args, jaxpr, n_consts, **kwargs): + """Translate a grad equation.""" + f = partial(copy(self).eval, jaxpr, args[:n_consts]) + new_jaxpr = jax.make_jaxpr(f)(*args[n_consts:]) - # Update the qnode with peephole pipeline - pass_pipeline = kwargs.pop("pass_pipeline", ()) or () - pass_pipeline += new_pipeline - pass_pipeline = dictionary_to_list_of_passes(pass_pipeline) - new_qnode = copy(self) - new_qnode._transform_program = new_transform_program # pylint: disable=protected-access + new_args = (*new_jaxpr.consts, *args[n_consts:]) + return pl_jac_prim.bind( + *new_args, jaxpr=new_jaxpr.jaxpr, n_consts=len(new_jaxpr.consts), **kwargs + ) - # Mid-circuit measurement configuration/execution - fn_result = configure_mcm_and_try_one_shot(new_qnode, args, kwargs) - # If the qnode is failed to execute as one-shot, fn_result will be None - if fn_result is not None: - return fn_result +# pylint: disable=unused-argument, too-many-arguments +@WorkflowInterpreter.register_primitive(qnode_prim) +def handle_qnode( + self, *args, qnode, device, shots_len, execution_config, qfunc_jaxpr, n_consts, batch_dims=None +): + """Handle the conversion from plxpr to Catalyst jaxpr for the qnode primitive""" - new_device = copy(new_qnode.device) - qjit_device = QJITDevice(new_device) + self.qubit_index_recorder = QubitIndexRecorder() - static_argnums = kwargs.pop("static_argnums", ()) - out_tree_expected = kwargs.pop("_out_tree_expected", []) - classical_return_indices = kwargs.pop("_classical_return_indices", []) - num_mcm_expected = kwargs.pop("_num_mcm_expected", []) - debug_info = kwargs.pop("debug_info", None) + if shots_len > 1: + raise NotImplementedError("shot vectors are not yet supported for catalyst conversion.") - print(new_qnode.transform_program) - print(pass_pipeline) + shots = args[0] if shots_len else 0 + consts = args[shots_len : n_consts + shots_len] + non_const_args = args[shots_len + n_consts :] - def _eval_quantum(*args, **kwargs): - trace_result = trace_quantum_function( - new_qnode.func, - qjit_device, - args, - kwargs, - new_qnode, - static_argnums, - debug_info, - ) - closed_jaxpr = trace_result.closed_jaxpr - out_type = trace_result.out_type - out_tree = trace_result.out_tree - out_tree_exp = trace_result.return_values_tree - cls_ret_idx = trace_result.classical_return_indices - num_mcm = trace_result.num_mcm - - out_tree_expected.append(out_tree_exp) - classical_return_indices.append(cls_ret_idx) - num_mcm_expected.append(num_mcm) - dynamic_args = filter_static_args(args, static_argnums) - args_expanded = get_implicit_and_explicit_flat_args(None, *dynamic_args, **kwargs) - res_expanded = eval_jaxpr(closed_jaxpr.jaxpr, closed_jaxpr.consts, *args_expanded) - _, out_keep = unzip2(out_type) - res_flat = [r for r, k in zip(res_expanded, out_keep) if k] - return tree_unflatten(out_tree, res_flat) - - flattened_fun, _, _, out_tree_promise = deduce_avals( - _eval_quantum, args, kwargs, static_argnums, debug_info + closed_jaxpr = ( + ClosedJaxpr(qfunc_jaxpr, consts) + if not self.requires_decompose_lowering + else _apply_compiler_decompose_to_plxpr( + inner_jaxpr=qfunc_jaxpr, + consts=consts, + ncargs=non_const_args, + tgateset=list(self.decompose_tkwargs.get("gate_set", [])), ) - dynamic_args = filter_static_args(args, static_argnums) - args_flat = tree_flatten((dynamic_args, kwargs))[0] - res_flat = quantum_kernel_p.bind( - flattened_fun, *args_flat, qnode=self, pipeline=tuple(pass_pipeline) - ) - return tree_unflatten(out_tree_promise(), res_flat)[0] - - -# pylint: disable=protected-access -def _get_shot_vector(qnode): - shot_vector = qnode._shots.shot_vector if qnode._shots else [] - return ( - shot_vector - if len(shot_vector) > 1 or any(copies > 1 for _, copies in shot_vector) - else None ) - -def _get_snapshot_results(mcm_method, tape, out): - """ - Get the snapshot results from the tape. - Args: - tape: The tape to get the snapshot results from. - out: The output of the tape. - Returns: - processed_snapshots: The extracted snapshot results if available; - otherwise, returns the original output. - measurement_results: The corresponding measurement results. - """ - # if no snapshot are present, return None, out - assert mcm_method == "one-shot" - - if not any(isinstance(op, qml.Snapshot) for op in tape.operations): - return None, out - - # Snapshots present: out[0] = snapshots, out[1] = measurements - snapshot_results, measurement_results = out - - # Take first shot for each snapshot - processed_snapshots = [ - snapshot[0] if hasattr(snapshot, "shape") and len(snapshot.shape) > 1 else snapshot - for snapshot in snapshot_results - ] - - return processed_snapshots, measurement_results - - -def _reshape_for_shot_vector(mcm_method, result, shot_vector): - assert mcm_method == "one-shot" - - # Calculate the shape for reshaping based on shot vector - result_list = [] - start_idx = 0 - for shot, copies in shot_vector: - # Reshape this segment to (copies, shot, n_wires) - segment = result[start_idx : start_idx + shot * copies] - if copies > 1: - segment_shape = (copies, shot, result.shape[-1]) - segment = jnp.reshape(segment, segment_shape) - result_list.extend([segment[i] for i in range(copies)]) - else: - result_list.append(segment) - start_idx += shot * copies - result = tuple(result_list) - return result - - -def _process_terminal_measurements(mcm_method, cpy_tape, out, snapshots, shot_vector): - """Process measurements when there are no mid-circuit measurements.""" - assert mcm_method == "one-shot" - - # flatten the outs structure - out, _ = tree_flatten(out) - new_out = [] - idx = 0 - - for m in cpy_tape.measurements: - if isinstance(m, CountsMP): - if isinstance(out[idx], tuple) and len(out[idx]) == 2: - # CountsMP result is stored as (keys, counts) tuple - keys, counts = out[idx] - idx += 1 - else: - keys = out[idx] - counts = out[idx + 1] - idx += 2 - - if snapshots is not None: - counts_array = jnp.stack(counts, axis=0) - aggregated_counts = jnp.sum(counts_array, axis=0) - counts_result = (keys, aggregated_counts) - else: - aggregated_counts = jnp.sum(counts, axis=0) - counts_result = (keys[0], aggregated_counts) - - new_out.append(counts_result) - continue - - result = jnp.squeeze(out[idx]) - max_ndim = min(len(out[idx].shape), 2) - if out[idx].shape[0] == 1: - # Adding the first axis back when the first axis in the original - # array is 1, since it corresponds to the shot's dimension. - result = jnp.expand_dims(result, axis=0) - if result.ndim == 1 and max_ndim == 2: - result = jnp.expand_dims(result, axis=1) - - # Without MCMs and postselection, all samples are valid for use in MP computation. - is_valid = jnp.full((result.shape[0],), True) - processed_result = gather_non_mcm( - m, result, is_valid, postselect_mode="pad-invalid-samples" + graph_succeeded = False + if self.requires_decompose_lowering: + closed_jaxpr, graph_succeeded = _collect_and_compile_graph_solutions( + inner_jaxpr=closed_jaxpr.jaxpr, + consts=closed_jaxpr.consts, + tkwargs=self.decompose_tkwargs, + ncargs=non_const_args, ) - # Handle shot vector reshaping for SampleMP - if isinstance(m, SampleMP) and shot_vector is not None: - processed_result = _reshape_for_shot_vector(mcm_method, processed_result, shot_vector) - - new_out.append(processed_result) - idx += 1 - - return (snapshots, tuple(new_out)) if snapshots else tuple(new_out) - - -def _validate_one_shot_measurements( - mcm_config, tape: qml.tape.QuantumTape, user_specified_mcm_method, shot_vector, wires -) -> None: - """Validate measurements for one-shot mode. - - Args: - mcm_config: The mid-circuit measurement configuration - tape: The quantum tape containing measurements to validate - qnode: The quantum node being transformed + # Fallback to the legacy decomposition if the graph-based decomposition failed + if not graph_succeeded: + # Remove the decompose-lowering pass from the pipeline + self._pass_pipeline = [p for p in self._pass_pipeline if p.name != "decompose-lowering"] + closed_jaxpr = _apply_compiler_decompose_to_plxpr( + inner_jaxpr=closed_jaxpr.jaxpr, + consts=closed_jaxpr.consts, + ncargs=non_const_args, + tkwargs=self.decompose_tkwargs, + ) - Raises: - TypeError: If unsupported measurement types are used - NotImplementedError: If measurement configuration is not supported - """ - mcm_method = mcm_config.mcm_method - assert mcm_method == "one-shot" + def calling_convention(*args): + device_init_p.bind( + shots, + auto_qubit_management=(device.wires is None), + **_get_device_kwargs(device), + ) + qreg = qalloc_p.bind(len(device.wires)) + self.init_qreg = QubitHandler(qreg, self.qubit_index_recorder) + converter = PLxPRToQuantumJaxprInterpreter( + device, shots, self.init_qreg, {}, self.qubit_index_recorder + ) + retvals = converter(closed_jaxpr, *args) + self.init_qreg.insert_all_dangling_qubits() + qdealloc_p.bind(self.init_qreg.get()) + device_release_p.bind() + return retvals + + if self.requires_decompose_lowering and graph_succeeded: + # Add gate_set attribute to the quantum kernel primitive + # decompose_gatesets is treated as a queue of gatesets to be used + # but we only support a single gateset for now in from_plxpr + # as supporting multiple gatesets requires an MLIR/C++ graph-decomposition + # implementation. The current Python implementation cannot be mixed + # with other transforms in between. + gateset = [_get_operator_name(op) for op in self.decompose_tkwargs.get("gate_set", [])] + setattr(qnode, "decompose_gatesets", [gateset]) + + return quantum_kernel_p.bind( + wrap_init(calling_convention, debug_info=qfunc_jaxpr.debug_info), + *non_const_args, + qnode=qnode, + pipeline=self._pass_pipeline, + ) - # Check if using shot vector with non-SampleMP measurements - has_shot_vector = len(shot_vector) > 1 or any(copies > 1 for _, copies in shot_vector) - has_wires = wires is not None and not is_dynamic_wires(wires) - # Raise an error if there are no mid-circuit measurements, it will fallback to - # single-branch-statistics +# The map below describes the parity between PL transforms and Catalyst passes. +# PL transforms having a Catalyst pass counterpart will have a name as value, +# otherwise their value will be None. The second value indicates if the transform +# requires decomposition to be supported by Catalyst. +transforms_to_passes = { + pl_cancel_inverses: ("remove-chained-self-inverse", False), + pl_commute_controlled: (None, False), + pl_decompose: (None, False), + pl_map_wires: (None, False), + pl_merge_amplitude_embedding: (None, True), + pl_merge_rotations: ("merge-rotations", False), + pl_single_qubit_fusion: (None, False), + pl_unitary_to_rot: (None, False), +} + + +def register_transform(pl_transform, pass_name, decomposition): + """Register pennylane transforms and their conversion to Catalyst transforms""" + transforms_to_passes[pl_transform] = (pass_name, decomposition) + + +# pylint: disable=too-many-arguments +@WorkflowInterpreter.register_primitive(transform_prim) +def handle_transform( + self, + *args, + args_slice, + consts_slice, + inner_jaxpr, + targs_slice, + tkwargs, + transform, +): + """Handle the conversion from plxpr to Catalyst jaxpr for a + PL transform.""" + consts = args[consts_slice] + non_const_args = args[args_slice] + targs = args[targs_slice] + + # If the transform is a decomposition transform + # and the graph-based decomposition is enabled if ( - not any(isinstance(op, MidCircuitMeasure) for op in tape.operations) - and user_specified_mcm_method is None + hasattr(transform._plxpr_transform, "__name__") + and transform._plxpr_transform.__name__ == "decompose_plxpr_to_plxpr" + and qml.decomposition.enabled_graph() ): - raise ValueError("No need to run one-shot mode when there are no mid-circuit measurements.") - - for m in tape.measurements: - # Check if measurement type is supported - if not isinstance(m, (CountsMP, ExpectationMP, ProbabilityMP, SampleMP, VarianceMP)): - raise TypeError( - f"Native mid-circuit measurement mode does not support {type(m).__name__} " - "measurements." - ) - - # Check variance with observable - if isinstance(m, VarianceMP) and m.obs: - raise TypeError( - "qml.var(obs) cannot be returned when `mcm_method='one-shot'` because " - "the Catalyst compiler does not support qml.sample(obs)." + if not self.requires_decompose_lowering: + self.requires_decompose_lowering = True + else: + raise NotImplementedError("Multiple decomposition transforms are not yet supported.") + + next_eval = copy(self) + # Update the decompose_gateset to be used by the quantum kernel primitive + # TODO: we originally wanted to treat decompose_gateset as a queue of + # gatesets to be used by the decompose-lowering pass at MLIR + # but this requires a C++ implementation of the graph-based decomposition + # which doesn't exist yet. + next_eval.decompose_tkwargs = tkwargs + + # Note. We don't perform the compiler-specific decomposition here + # to be able to support multiple decomposition transforms + # and collect all the required gatesets + # as well as being able to support other transforms in between. + + # The compiler specific transformation will be performed + # in the qnode handler. + + # Add the decompose-lowering pass to the start of the pipeline + next_eval._pass_pipeline.insert(0, Pass("decompose-lowering")) + + # We still need to construct and solve the graph based on + # the current jaxpr based on the current gateset + # but we don't rewrite the jaxpr at this stage. + + # gds_interpreter = DecompRuleInterpreter(*targs, **tkwargs) + + # def gds_wrapper(*args): + # return gds_interpreter.eval(inner_jaxpr, consts, *args) + + # final_jaxpr = jax.make_jaxpr(gds_wrapper)(*args) + # return self.eval(final_jaxpr.jaxpr, consts, *non_const_args) + return next_eval.eval(inner_jaxpr, consts, *non_const_args) + + catalyst_pass_name = transforms_to_passes.get(transform, (None,))[0] + if catalyst_pass_name is None: + # Use PL's ExpandTransformsInterpreter to expand this and any embedded + # transform according to PL rules. It works by overriding the primitive + # registration, making all embedded transforms follow the PL rules + # from now on, hence ignoring the Catalyst pass conversion + def wrapper(*args): + return ExpandTransformsInterpreter().eval(inner_jaxpr, consts, *args) + + unravelled_jaxpr = jax.make_jaxpr(wrapper)(*non_const_args) + final_jaxpr = transform._plxpr_transform( + unravelled_jaxpr.jaxpr, unravelled_jaxpr.consts, targs, tkwargs, *non_const_args + ) + if transforms_to_passes[transform][1]: + final_jaxpr = pl_decompose._plxpr_transform( + final_jaxpr.jaxpr, final_jaxpr.consts, targs, tkwargs, *non_const_args ) - # Check if the measurement is supported with shot-vector - if has_shot_vector and not isinstance(m, SampleMP): - raise NotImplementedError( - f"Measurement {type(m).__name__} does not support shot-vectors. " - "Use qml.sample() instead." - ) + return copy(self).eval(final_jaxpr.jaxpr, final_jaxpr.consts, *non_const_args) - # Check dynamic wires with empty wires - if not has_wires and isinstance(m, (SampleMP, CountsMP)) and (m.wires.tolist() == []): - raise NotImplementedError( - f"Measurement {type(m).__name__} with empty wires is not supported with " - "dynamic wires in one-shot mode. Please specify a constant number of wires on " - "the device." - ) + # Apply the corresponding Catalyst pass counterpart + next_eval = copy(self) + next_eval._pass_pipeline.insert(0, Pass(catalyst_pass_name, *targs, **tkwargs)) + return next_eval.eval(inner_jaxpr, consts, *non_const_args) -# pylint: disable=protected-access,no-member,not-callable -def dynamic_one_shot(qnode, **kwargs): - """Transform a QNode to into several one-shot tapes to support dynamic circuit execution. +# pylint: disable=too-many-positional-arguments +def trace_from_pennylane( + fn, static_argnums, dynamic_args, abstracted_axes, sig, kwargs, debug_info=None +): + """Capture the JAX program representation (JAXPR) of the wrapped function, using + PL capure module. Args: - qnode (QNode): a quantum circuit which will run ``num_shots`` times + fn(Callable): the user function to be traced + static_argnums(int or Seqence[Int]): an index or a sequence of indices that specifies the + positions of static arguments. + dynamic_args(Seqence[Any]): the abstract values of the dynamic arguments. + abstracted_axes (Sequence[Sequence[str]] or Dict[int, str] or Sequence[Dict[int, str]]): + An experimental option to specify dynamic tensor shapes. + This option affects the compilation of the annotated function. + Function arguments with ``abstracted_axes`` specified will be compiled to ranked tensors + with dynamic shapes. For more details, please see the Dynamically-shaped Arrays section + below. + sig(Sequence[Any]): a tuple indicating the argument signature of the function. Static arguments + are indicated with their literal values, and dynamic arguments are indicated by abstract + values. + kwargs(Dict[str, Any]): keyword argumemts to the function. + debug_info(jax.api_util.debug_info): a source debug information object required by jaxprs. Returns: - qnode (QNode): - - The transformed circuit to be run ``num_shots`` times such as to simulate dynamic execution. - - - **Example** - - Consider the following circuit: - - .. code-block:: python - - dev = qml.device("lightning.qubit", shots=100) - params = np.pi / 4 * np.ones(2) - - @qjit - @dynamic_one_shot - @qml.qnode(dev, diff_method=None) - def circuit(x, y): - qml.RX(x, wires=0) - m0 = measure(0, reset=reset, postselect=postselect) + ClosedJaxpr: captured JAXPR + Tuple[Tuple[ShapedArray, bool]]: the return type of the captured JAXPR. + The boolean indicates whether each result is a value returned by the user function. + PyTreeDef: PyTree metadata of the function output + Tuple[Any]: the dynamic argument signature + """ - @cond(m0 == 1) - def ansatz(): - qml.RY(y, wires=1) + with transient_jax_config({"jax_dynamic_shapes": True}): - ansatz() - return measure_f(wires=[0, 1]) + make_jaxpr_kwargs = { + "static_argnums": static_argnums, + "abstracted_axes": abstracted_axes, + "debug_info": debug_info, + } - The ``dynamic_one_shot`` decorator prompts the QNode to perform a hundred one-shot - calculations, where in each calculation the ``measure`` operations dynamically - measures the 0-wire and collapse the state vector stochastically. - """ + args = sig - cpy_tape = None - mcm_config = kwargs.pop("mcm_config", None) + if isinstance(fn, qml.QNode) and static_argnums: + # `make_jaxpr2` sees the qnode + # The static_argnum on the wrapped function takes precedence over the + # one in `make_jaxpr` + # https://github.com/jax-ml/jax/blob/636691bba40b936b8b64a4792c1d2158296e9dd4/jax/_src/linear_util.py#L231 + # Therefore we need to coordinate them manually + fn.static_argnums = static_argnums - def transform_to_single_shot(qnode): - if not qnode._shots: - raise exceptions.QuantumFunctionError( - "dynamic_one_shot is only supported with finite shots." - ) + plxpr, out_type, out_treedef = make_jaxpr2(fn, **make_jaxpr_kwargs)(*args, **kwargs) + jaxpr = from_plxpr(plxpr)(*plxpr.in_avals) - user_specified_mcm_method = qnode.execute_kwargs["mcm_method"] - shot_vector = qnode._shots.shot_vector if qnode._shots else [] - wires = qnode.device.wires + return jaxpr, out_type, out_treedef, sig - @qml.transform - def dynamic_one_shot_partial( - tape: qml.tape.QuantumTape, - ) -> tuple[Sequence[qml.tape.QuantumTape], Callable]: - nonlocal cpy_tape - cpy_tape = tape - _validate_one_shot_measurements( - mcm_config, tape, user_specified_mcm_method, shot_vector, wires - ) +def _apply_compiler_decompose_to_plxpr(inner_jaxpr, consts, ncargs, tgateset=None, tkwargs=None): + """Apply the compiler-specific decomposition for a given JAXPR. - if tape.batch_size is not None: - raise ValueError("mcm_method='one-shot' is not compatible with broadcasting") + This function first disables the graph-based decomposition optimization + to ensure that only high-level gates and templates with a single decomposition + are decomposed. It then performs the pre-mlir decomposition using PennyLane's + `plxpr_transform` function. - aux_tapes = [init_auxiliary_tape(tape)] + `tgateset` is a list of target gateset for decomposition. + If provided, it will be combined with the default compiler ops for decomposition. + If not provided, `tkwargs` will be used as the keyword arguments for the + decomposition transform. This is to ensure compatibility with the existing + PennyLane decomposition transform as well as providing a fallback mechanism. - def processing_fn(results): - return results + Args: + inner_jaxpr (Jaxpr): The input JAXPR to be decomposed. + consts (list): The constants used in the JAXPR. + ncargs (list): Non-constant arguments for the JAXPR. + tgateset (list): A list of target gateset for decomposition. Defaults to None. + tkwargs (list): The keyword arguments of the decompose transform. Defaults to None. - return aux_tapes, processing_fn + Returns: + ClosedJaxpr: The decomposed JAXPR. + """ - return dynamic_one_shot_partial(qnode) + # Disable the graph decomposition optimization + + # Why? Because for the compiler-specific decomposition we want to + # only decompose higher-level gates and templates that only have + # a single decomposition, and not do any further optimization + # based on the graph solution. + # Besides, the graph-based decomposition is not supported + # yet in from_plxpr for most gates and templates. + # TODO: Enable the graph-based decomposition + qml.decomposition.disable_graph() + + kwargs = ( + {"gate_set": set(COMPILER_OPS_FOR_DECOMPOSITION.keys()).union(tgateset)} + if tgateset + else tkwargs + ) + final_jaxpr = qml.transforms.decompose.plxpr_transform(inner_jaxpr, consts, (), kwargs, *ncargs) - single_shot_qnode = transform_to_single_shot(qnode) - single_shot_qnode = qml.set_shots(single_shot_qnode, shots=1) - if mcm_config is not None: - single_shot_qnode.execute_kwargs["postselect_mode"] = mcm_config.postselect_mode - single_shot_qnode.execute_kwargs["mcm_method"] = mcm_config.mcm_method - single_shot_qnode._dynamic_one_shot_called = True - total_shots = _get_total_shots(qnode) + qml.decomposition.enable_graph() - def one_shot_wrapper(*args, **kwargs): - def wrap_single_shot_qnode(*_): - return single_shot_qnode(*args, **kwargs) + return final_jaxpr - arg_vmap = jnp.empty((total_shots,), dtype=float) - results = catalyst.vmap(wrap_single_shot_qnode)(arg_vmap) - if isinstance(results[0], tuple) and len(results) == 1: - results = results[0] - has_mcm = any(isinstance(op, MidCircuitMeasure) for op in cpy_tape.operations) - classical_return_indices = kwargs.pop("_classical_return_indices", [[]])[0] - num_mcm = kwargs.pop("_num_mcm_expected", [0])[0] - out_tree_expected = kwargs.pop("_out_tree_expected", [[]]) +def _collect_and_compile_graph_solutions(inner_jaxpr, consts, tkwargs, ncargs): + """Collect and compile graph solutions for a given JAXPR. - # Split results into classical and measurement parts - classical_values, results = _extract_classical_and_measurement_results( - results, classical_return_indices - ) + This function uses the DecompRuleInterpreter to evaluate + the input JAXPR and obtain a new JAXPR that incorporates + the graph-based decomposition solutions. - out = list(results) + This function doesn't modify the underlying quantum function + but rather constructs a new JAXPR with decomposition rules. - shot_vector = _get_shot_vector(qnode) - snapshots, out = _get_snapshot_results(mcm_config.mcm_method, cpy_tape, out) + Args: + inner_jaxpr (Jaxpr): The input JAXPR to be decomposed. + consts (list): The constants used in the JAXPR. + tkwargs (list): The keyword arguments of the decompose transform. + ncargs (list): Non-constant arguments for the JAXPR. - if has_mcm and len(cpy_tape.measurements) > 0: - out = parse_native_mid_circuit_measurements( - cpy_tape, results=results, postselect_mode="pad-invalid-samples" - ) - if len(cpy_tape.measurements) == 1: - out = (out,) - elif len(cpy_tape.measurements) > 0: - out = _process_terminal_measurements( - mcm_config.mcm_method, cpy_tape, out, snapshots, shot_vector + Returns: + ClosedJaxpr: The decomposed JAXPR. + bool: A flag indicating whether the graph-based decomposition was successful. + """ + gds_interpreter = DecompRuleInterpreter(**tkwargs) + + def gds_wrapper(*args): + return gds_interpreter.eval(inner_jaxpr, consts, *args) + + graph_succeeded = True + + with warnings.catch_warnings(record=True) as captured_warnings: + warnings.simplefilter("always", UserWarning) + final_jaxpr = jax.make_jaxpr(gds_wrapper)(*ncargs) + + for w in captured_warnings: + warnings.showwarning(w.message, w.category, w.filename, w.lineno) + # TODO: use a custom warning class for this in PennyLane to remove this + # string matching and make it more robust. + if "The graph-based decomposition system is unable" in str(w.message): # pragma: no cover + graph_succeeded = False + warnings.warn( + "Falling back to the legacy decomposition system.", + UserWarning, ) - ctx = OutputContext( - cpy_tape=cpy_tape, - classical_values=classical_values, - classical_return_indices=classical_return_indices, - out_tree_expected=out_tree_expected, - snapshots=snapshots, - shot_vector=shot_vector, - num_mcm=num_mcm, - ) + return final_jaxpr, graph_succeeded - return _finalize_output(out, ctx) - return one_shot_wrapper +def _get_operator_name(op): + """Get the name of a pennylane operator, handling wrapped operators. + Note: Controlled and Adjoint ops aren't supported in `gate_set` + by PennyLane's DecompositionGraph; unit tests were added in PennyLane. + """ + if isinstance(op, str): + return op -def _extract_passes(transform_program): - tape_transforms = [] - pass_pipeline = [] - for t in transform_program: - if t.pass_name: - pass_pipeline.append(Pass(t.pass_name, *t.args, **t.kwargs)) - else: - tape_transforms.append(t) - return qml.transforms.core.TransformProgram(tape_transforms), tuple(pass_pipeline) \ No newline at end of file + # Return NoNameOp if the operator has no _primitive.name attribute. + # This is to avoid errors when we capture the program + # as we deal with such ops later in the decomposition graph. + return getattr(op._primitive, "name", "NoNameOp") diff --git a/frontend/catalyst/from_plxpr/qfunc_interpreter.py b/frontend/catalyst/from_plxpr/qfunc_interpreter.py index 25b6cb90d8..29c3aade1a 100644 --- a/frontend/catalyst/from_plxpr/qfunc_interpreter.py +++ b/frontend/catalyst/from_plxpr/qfunc_interpreter.py @@ -17,6 +17,7 @@ # pylint: disable=protected-access import textwrap from copy import copy +from functools import partial import jax import jax.numpy as jnp @@ -66,6 +67,7 @@ from .qubit_handler import ( QubitHandler, QubitIndexRecorder, + _get_dynamically_allocated_qregs, get_in_qubit_values, is_dynamically_allocated_wire, ) @@ -156,7 +158,9 @@ def interpret_operation(self, op, is_adjoint=False, control_values=(), control_w if any(not qreg.is_qubit_mode() and qreg.expired for qreg in in_qregs + in_ctrl_qregs): raise CompileError(f"Deallocated qubits cannot be used, but used in {op.name}.") - out_qubits = qinst_p.bind( + bind_fn = _special_op_bind_call.get(type(op), qinst_p.bind) + + out_qubits = bind_fn( *[*in_qubits, *op.data, *in_ctrl_qubits, *control_values], op=op.name, qubits_len=len(op.wires), @@ -164,7 +168,6 @@ def interpret_operation(self, op, is_adjoint=False, control_values=(), control_w ctrl_len=len(control_wires), adjoint=is_adjoint, ) - out_non_ctrl_qubits = out_qubits[: len(out_qubits) - len(control_wires)] out_ctrl_qubits = out_qubits[-len(control_wires) :] @@ -275,6 +278,27 @@ def __call__(self, jaxpr, *args): return self.eval(jaxpr.jaxpr, jaxpr.consts, *args) +# pylint: disable=unused-argument +def _qubit_unitary_bind_call(*invals, op, qubits_len, params_len, ctrl_len, adjoint): + wires = invals[:qubits_len] + mat = invals[qubits_len] + ctrl_inputs = invals[qubits_len + 1 :] + return unitary_p.bind( + mat, *wires, *ctrl_inputs, qubits_len=qubits_len, ctrl_len=ctrl_len, adjoint=adjoint + ) + + +# pylint: disable=unused-argument +def _gphase_bind_call(*invals, op, qubits_len, params_len, ctrl_len, adjoint): + return gphase_p.bind(*invals[qubits_len:], ctrl_len=ctrl_len, adjoint=adjoint) + + +_special_op_bind_call = { + qml.QubitUnitary: _qubit_unitary_bind_call, + qml.GlobalPhase: _gphase_bind_call, +} + + # pylint: disable=unused-argument @PLxPRToQuantumJaxprInterpreter.register_primitive(qml.allocation.allocate_prim) def handle_qml_alloc(self, *, num_wires, state=None, restored=False): @@ -316,22 +340,73 @@ def interpret_counts(self, *wires, all_outcomes): return keys, vals +def _subroutine_kernel( + interpreter, + jaxpr, + *qregs_plus_args, + outer_dynqreg_handlers=(), + wire_label_arg_to_tracer_arg_index=(), + wire_to_owner_qreg=(), +): + global_qreg, *dynqregs_plus_args = qregs_plus_args + num_dynamic_alloced_qregs = len(outer_dynqreg_handlers) + dynalloced_qregs, args = ( + dynqregs_plus_args[:num_dynamic_alloced_qregs], + dynqregs_plus_args[num_dynamic_alloced_qregs:], + ) + + # Launch a new interpreter for the body region + # A new interpreter's root qreg value needs a new recorder + converter = copy(interpreter) + converter.qubit_index_recorder = QubitIndexRecorder() + init_qreg = QubitHandler(global_qreg, converter.qubit_index_recorder) + converter.init_qreg = init_qreg + + # add dynamic qregs to recorder + qreg_map = {} + dyn_qreg_handlers = [] + arg_to_qreg = {} + for dyn_qreg, outer_dynqreg_handler in zip( + dynalloced_qregs, outer_dynqreg_handlers, strict=True + ): + dyn_qreg_handler = QubitHandler(dyn_qreg, converter.qubit_index_recorder) + dyn_qreg_handlers.append(dyn_qreg_handler) + + # plxpr global wire index does not change across scopes + # So scope arg dynamic qregs need to have the same root hash as their corresponding + # qreg tracers outside + dyn_qreg_handler.root_hash = outer_dynqreg_handler.root_hash + + # Each qreg argument of the subscope corresponds to a qreg from the outer scope + qreg_map[outer_dynqreg_handler] = dyn_qreg_handler + + for global_idx, arg_idx in wire_label_arg_to_tracer_arg_index.items(): + arg_to_qreg[args[arg_idx]] = qreg_map[wire_to_owner_qreg[global_idx]] + + # The new interpreter's recorder needs to be updated to include the qreg args + # of this scope, instead of the outer qregs + for arg in args: + if arg in arg_to_qreg: + converter.qubit_index_recorder[arg] = arg_to_qreg[arg] + + retvals = converter(jaxpr, *args) + + init_qreg.insert_all_dangling_qubits() + + # Return all registers + for dyn_qreg_handler in reversed(dyn_qreg_handlers): + dyn_qreg_handler.insert_all_dangling_qubits() + retvals.insert(0, dyn_qreg_handler.get()) + + return converter.init_qreg.get(), *retvals + + @PLxPRToQuantumJaxprInterpreter.register_primitive(quantum_subroutine_p) def handle_subroutine(self, *args, **kwargs): """ Transform the subroutine from PLxPR into JAXPR with quantum primitives. """ - if any(is_dynamically_allocated_wire(arg) for arg in args): - raise NotImplementedError( - textwrap.dedent( - """ - Dynamically allocated wires in a parent scope cannot be used in a child - scope yet. Please consider dynamical allocation inside the child scope. - """ - ) - ) - backup = dict(self.init_qreg) self.init_qreg.insert_all_dangling_qubits() @@ -339,20 +414,34 @@ def handle_subroutine(self, *args, **kwargs): plxpr = kwargs["jaxpr"] transformed = self.subroutine_cache.get(plxpr) - def wrapper(qreg, *args): - # Launch a new interpreter for the new subroutine region - # A new interpreter's root qreg value needs a new recorder - converter = copy(self) - converter.qubit_index_recorder = QubitIndexRecorder() - init_qreg = QubitHandler(qreg, converter.qubit_index_recorder) - converter.init_qreg = init_qreg - - retvals = converter(plxpr, *args) - converter.init_qreg.insert_all_dangling_qubits() - return converter.init_qreg.get(), *retvals + dynalloced_qregs, dynalloced_wire_global_indices = _get_dynamically_allocated_qregs( + args, self.qubit_index_recorder, self.init_qreg + ) + wire_to_owner_qreg = dict(zip(dynalloced_wire_global_indices, dynalloced_qregs)) + dynalloced_qregs = list(dict.fromkeys(dynalloced_qregs)) # squash duplicates + + # Convert global wire indices into local indices + new_args = () + wire_label_arg_to_tracer_arg_index = {} + for i, arg in enumerate(args): + if arg in dynalloced_wire_global_indices: + wire_label_arg_to_tracer_arg_index[arg] = i + new_args += (self.qubit_index_recorder[arg].global_index_to_local_index(arg),) + else: + new_args += (arg,) if not transformed: - converted_closed_jaxpr_branch = jax.make_jaxpr(wrapper)(self.init_qreg.get(), *args) + f = partial( + _subroutine_kernel, + self, + plxpr, + outer_dynqreg_handlers=dynalloced_qregs, + wire_label_arg_to_tracer_arg_index=wire_label_arg_to_tracer_arg_index, + wire_to_owner_qreg=wire_to_owner_qreg, + ) + converted_closed_jaxpr_branch = jax.make_jaxpr(f)( + self.init_qreg.get(), *[dyn_qreg.get() for dyn_qreg in dynalloced_qregs], *args + ) self.subroutine_cache[plxpr] = converted_closed_jaxpr_branch else: converted_closed_jaxpr_branch = transformed @@ -361,12 +450,13 @@ def wrapper(qreg, *args): # is just pjit_p with a different name. vals_out = quantum_subroutine_p.bind( self.init_qreg.get(), - *args, + *[dyn_qreg.get() for dyn_qreg in dynalloced_qregs], + *new_args, jaxpr=converted_closed_jaxpr_branch, - in_shardings=(UNSPECIFIED, *kwargs["in_shardings"]), - out_shardings=(UNSPECIFIED, *kwargs["out_shardings"]), - in_layouts=(None, *kwargs["in_layouts"]), - out_layouts=(None, *kwargs["out_layouts"]), + in_shardings=(*(UNSPECIFIED,) * (len(dynalloced_qregs) + 1), *kwargs["in_shardings"]), + out_shardings=(*(UNSPECIFIED,) * (len(dynalloced_qregs) + 1), *kwargs["out_shardings"]), + in_layouts=(*(None,) * (len(dynalloced_qregs) + 1), *kwargs["in_layouts"]), + out_layouts=(*(None,) * (len(dynalloced_qregs) + 1), *kwargs["out_layouts"]), donated_invars=kwargs["donated_invars"], ctx_mesh=kwargs["ctx_mesh"], name=kwargs["name"], @@ -376,7 +466,9 @@ def wrapper(qreg, *args): ) self.init_qreg.set(vals_out[0]) - vals_out = vals_out[1:] + for i, dyn_qreg in enumerate(dynalloced_qregs): + dyn_qreg.set(vals_out[i + 1]) + vals_out = vals_out[len(dynalloced_qregs) + 1 :] for orig_wire in backup.keys(): self.init_qreg.extract(orig_wire) @@ -441,22 +533,6 @@ def wrapper(*args): return () -@PLxPRToQuantumJaxprInterpreter.register_primitive(qml.QubitUnitary._primitive) -def handle_qubit_unitary(self, *invals, n_wires): - """Handle the conversion from plxpr to Catalyst jaxpr for the QubitUnitary primitive""" - in_qregs, in_qubits = get_in_qubit_values(invals[1:], self.qubit_index_recorder, self.init_qreg) - outvals = unitary_p.bind(invals[0], *in_qubits, qubits_len=n_wires, ctrl_len=0, adjoint=False) - for in_qreg, w, new_wire in zip(in_qregs, invals[1:], outvals): - in_qreg[in_qreg.global_index_to_local_index(w)] = new_wire - - -# pylint: disable=unused-argument -@PLxPRToQuantumJaxprInterpreter.register_primitive(qml.GlobalPhase._primitive) -def handle_global_phase(self, phase, *wires, n_wires): - """Handle the conversion from plxpr to Catalyst jaxpr for the GlobalPhase primitive""" - gphase_p.bind(phase, ctrl_len=0, adjoint=False) - - @PLxPRToQuantumJaxprInterpreter.register_primitive(qml.BasisState._primitive) def handle_basis_state(self, *invals, n_wires): """Handle the conversion from plxpr to Catalyst jaxpr for the BasisState primitive""" @@ -565,6 +641,12 @@ def handle_adjoint_transform( n_consts, ): """Handle the conversion from plxpr to Catalyst jaxpr for the adjoint primitive""" + + if any(is_dynamically_allocated_wire(arg) for arg in plxpr_invals): + raise NotImplementedError( + "Dynamically allocated wires cannot be used in quantum adjoints yet." + ) + assert jaxpr is not None consts = plxpr_invals[:n_consts] args = plxpr_invals[n_consts:] @@ -590,13 +672,16 @@ def calling_convention(*args_plus_qreg): init_qreg.insert_all_dangling_qubits() return *retvals, converter.init_qreg.get() - _, args_tree = tree_flatten((consts, args, [qreg])) - converted_jaxpr_branch = jax.make_jaxpr(calling_convention)(*consts, *args, qreg).jaxpr + converted_jaxpr_branch = jax.make_jaxpr(calling_convention)(*args, qreg) - converted_closed_jaxpr_branch = ClosedJaxpr(convert_constvars_jaxpr(converted_jaxpr_branch), ()) + converted_closed_jaxpr_branch = ClosedJaxpr( + convert_constvars_jaxpr(converted_jaxpr_branch.jaxpr), () + ) + new_consts = converted_jaxpr_branch.consts + _, args_tree = tree_flatten((new_consts, args, [qreg])) # Perform the binding outvals = adjoint_p.bind( - *consts, + *new_consts, *args, qreg, jaxpr=converted_closed_jaxpr_branch, diff --git a/frontend/catalyst/from_plxpr/qubit_handler.py b/frontend/catalyst/from_plxpr/qubit_handler.py index f9adb55e6c..b7a54b76f2 100644 --- a/frontend/catalyst/from_plxpr/qubit_handler.py +++ b/frontend/catalyst/from_plxpr/qubit_handler.py @@ -68,8 +68,6 @@ qubit SSA values on its wires? """ -import textwrap - from catalyst.jax_extras import DynamicJaxprTracer from catalyst.jax_primitives import AbstractQbit, AbstractQreg, qextract_p, qinsert_p from catalyst.utils.exceptions import CompileError @@ -422,21 +420,6 @@ def get_in_qubit_values( if not qubit_index_recorder.contains(w): # First time the global wire index w is encountered # Need to extract from fallback qreg - # TODO: this can now only be from the global qreg, because right now in from_plxpr - # conversion, subscopes (control flow, adjoint, ...) can only take in the global - # qreg as the final scope argument. They cannot take an arbitrary number of qreg - # values yet. - # Supporting multiple registers requires refactoring the from_plxpr conversion's - # implementation. - if is_dynamically_allocated_wire(w): - raise NotImplementedError( - textwrap.dedent( - """ - Dynamically allocated wires in a parent scope cannot be used in a child - scope yet. Please consider dynamical allocation inside the child scope. - """ - ) - ) in_qubits.append(fallback_qreg[fallback_qreg.global_index_to_local_index(w)]) in_qregs.append(fallback_qreg) @@ -446,3 +429,28 @@ def get_in_qubit_values( in_qubits.append(in_qreg[in_qreg.global_index_to_local_index(w)]) return in_qregs, in_qubits + + +def _get_dynamically_allocated_qregs(plxpr_invals, qubit_index_recorder, init_qreg): + """ + Get the potential dynamically allocated register values that are visible to a jaxpr. + + Note that dynamically allocated wires have their qreg tracer's id as the global wire index + so the sub jaxpr takes that id in as a "const", since it is closure from the target wire + of gates/measurements/... + We need to remove that const, so we also let this util return these global indices. + """ + dynalloced_qregs = [] + dynalloced_wire_global_indices = [] + for inval in plxpr_invals: + if ( + isinstance(inval, int) + and qubit_index_recorder.contains(inval) + and qubit_index_recorder[inval] is not init_qreg + ): + dyn_qreg = qubit_index_recorder[inval] + dyn_qreg.insert_all_dangling_qubits() + dynalloced_qregs.append(dyn_qreg) + dynalloced_wire_global_indices.append(inval) + + return dynalloced_qregs, dynalloced_wire_global_indices From 3b2c5b85ccd6090f863082ac5ab44993f379f35a Mon Sep 17 00:00:00 2001 From: albi3ro Date: Thu, 13 Nov 2025 14:56:25 -0500 Subject: [PATCH 05/24] more polishing --- frontend/catalyst/from_plxpr/from_plxpr.py | 87 ++++++++++++---------- frontend/catalyst/jax_primitives_utils.py | 3 +- frontend/catalyst/qfunc.py | 28 ++++--- 3 files changed, 69 insertions(+), 49 deletions(-) diff --git a/frontend/catalyst/from_plxpr/from_plxpr.py b/frontend/catalyst/from_plxpr/from_plxpr.py index 86720baf5a..d19f6e8006 100644 --- a/frontend/catalyst/from_plxpr/from_plxpr.py +++ b/frontend/catalyst/from_plxpr/from_plxpr.py @@ -273,6 +273,47 @@ def register_transform(pl_transform, pass_name, decomposition): transforms_to_passes[pl_transform] = (pass_name, decomposition) +def _handle_decompose_transform(self, inner_jaxpr, consts, non_const_args, targs, tkwargs): + if not self.requires_decompose_lowering: + self.requires_decompose_lowering = True + else: + raise NotImplementedError("Multiple decomposition transforms are not yet supported.") + + next_eval = copy(self) + # Update the decompose_gateset to be used by the quantum kernel primitive + # TODO: we originally wanted to treat decompose_gateset as a queue of + # gatesets to be used by the decompose-lowering pass at MLIR + # but this requires a C++ implementation of the graph-based decomposition + # which doesn't exist yet. + next_eval.decompose_tkwargs = tkwargs + + # Note. We don't perform the compiler-specific decomposition here + # to be able to support multiple decomposition transforms + # and collect all the required gatesets + # as well as being able to support other transforms in between. + + # The compiler specific transformation will be performed + # in the qnode handler. + + # Add the decompose-lowering pass to the start of the pipeline + t = qml.transform(pass_name="decompose-lowering") + pass_container = qml.transforms.core.TransformContainer(t, args=targs, kwargs=tkwargs) + next_eval._pass_pipeline.insert(0, pass_container) + + # We still need to construct and solve the graph based on + # the current jaxpr based on the current gateset + # but we don't rewrite the jaxpr at this stage. + + # gds_interpreter = DecompRuleInterpreter(*targs, **tkwargs) + + # def gds_wrapper(*args): + # return gds_interpreter.eval(inner_jaxpr, consts, *args) + + # final_jaxpr = jax.make_jaxpr(gds_wrapper)(*args) + # return self.eval(final_jaxpr.jaxpr, consts, *non_const_args) + return next_eval.eval(inner_jaxpr, consts, *non_const_args) + + # pylint: disable=too-many-arguments @WorkflowInterpreter.register_primitive(transform_prim) def handle_transform( @@ -298,44 +339,13 @@ def handle_transform( and transform._plxpr_transform.__name__ == "decompose_plxpr_to_plxpr" and qml.decomposition.enabled_graph() ): - if not self.requires_decompose_lowering: - self.requires_decompose_lowering = True - else: - raise NotImplementedError("Multiple decomposition transforms are not yet supported.") - - next_eval = copy(self) - # Update the decompose_gateset to be used by the quantum kernel primitive - # TODO: we originally wanted to treat decompose_gateset as a queue of - # gatesets to be used by the decompose-lowering pass at MLIR - # but this requires a C++ implementation of the graph-based decomposition - # which doesn't exist yet. - next_eval.decompose_tkwargs = tkwargs - - # Note. We don't perform the compiler-specific decomposition here - # to be able to support multiple decomposition transforms - # and collect all the required gatesets - # as well as being able to support other transforms in between. - - # The compiler specific transformation will be performed - # in the qnode handler. - - # Add the decompose-lowering pass to the start of the pipeline - next_eval._pass_pipeline.insert(0, Pass("decompose-lowering")) - - # We still need to construct and solve the graph based on - # the current jaxpr based on the current gateset - # but we don't rewrite the jaxpr at this stage. - - # gds_interpreter = DecompRuleInterpreter(*targs, **tkwargs) - - # def gds_wrapper(*args): - # return gds_interpreter.eval(inner_jaxpr, consts, *args) - - # final_jaxpr = jax.make_jaxpr(gds_wrapper)(*args) - # return self.eval(final_jaxpr.jaxpr, consts, *non_const_args) - return next_eval.eval(inner_jaxpr, consts, *non_const_args) + return _handle_decompose_transform( + self, inner_jaxpr, consts, non_const_args, targs, tkwargs + ) - catalyst_pass_name = transforms_to_passes.get(transform, (None,))[0] + catalyst_pass_name = transform.pass_name + if catalyst_pass_name is None: + catalyst_pass_name = transforms_to_passes.get(transform, (None,))[0] if catalyst_pass_name is None: # Use PL's ExpandTransformsInterpreter to expand this and any embedded # transform according to PL rules. It works by overriding the primitive @@ -357,7 +367,8 @@ def wrapper(*args): # Apply the corresponding Catalyst pass counterpart next_eval = copy(self) - next_eval._pass_pipeline.insert(0, Pass(catalyst_pass_name, *targs, **tkwargs)) + bound_pass = qml.transforms.core.TransformContainer(transform, args=targs, kwargs=tkwargs) + next_eval._pass_pipeline.insert(0, bound_pass) return next_eval.eval(inner_jaxpr, consts, *non_const_args) diff --git a/frontend/catalyst/jax_primitives_utils.py b/frontend/catalyst/jax_primitives_utils.py index 0a50d0aad6..d9e753efe2 100644 --- a/frontend/catalyst/jax_primitives_utils.py +++ b/frontend/catalyst/jax_primitives_utils.py @@ -327,6 +327,7 @@ def _lowered_options(kwargs): lowered_options[mlir_option] = get_mlir_attribute_from_pyval(value) return lowered_options + def transform_named_sequence_lowering(jax_ctx: mlir.LoweringRuleContext, pipeline): """Generate a transform module embedded in the current module and schedule the transformations in pipeline""" @@ -394,7 +395,7 @@ def transform_named_sequence_lowering(jax_ctx: mlir.LoweringRuleContext, pipelin is_xdsl_pass, ) - if is_xdsl_pass(_pass.name): + if is_xdsl_pass(name): uses_xdsl_passes = True apply_registered_pass_op.operation.attributes["catalyst.xdsl_pass"] = ( ir.UnitAttr.get() diff --git a/frontend/catalyst/qfunc.py b/frontend/catalyst/qfunc.py index fab0d2e090..dbca8c649b 100644 --- a/frontend/catalyst/qfunc.py +++ b/frontend/catalyst/qfunc.py @@ -43,7 +43,7 @@ from catalyst.jax_primitives import quantum_kernel_p from catalyst.jax_tracer import Function, trace_quantum_function from catalyst.logging import debug_logger -from catalyst.passes.pass_api import dictionary_to_list_of_passes, Pass +from catalyst.passes.pass_api import Pass, dictionary_to_list_of_passes from catalyst.tracing.contexts import EvaluationContext from catalyst.tracing.type_signatures import filter_static_args from catalyst.utils.exceptions import CompileError @@ -284,12 +284,12 @@ def __call__(self, *args, **kwargs): assert isinstance(self, qml.QNode) new_transform_program, new_pipeline = _extract_passes(self.transform_program) - # Update the qnode with peephole pipeline - pass_pipeline = kwargs.pop("pass_pipeline", []) + new_pipeline + old_pipeline = kwargs.pop("pass_pipeline", ()) or () + pass_pipeline = old_pipeline + new_pipeline pass_pipeline = dictionary_to_list_of_passes(pass_pipeline) new_qnode = copy(self) - new_qnode._transform_program = new_transform_program # pylint: disable=protected-access + new_qnode._transform_program = new_transform_program # pylint: disable=protected-access # Mid-circuit measurement configuration/execution fn_result = configure_mcm_and_try_one_shot(new_qnode, args, kwargs) @@ -656,11 +656,19 @@ def wrap_single_shot_qnode(*_): def _extract_passes(transform_program): + """Extract transforms with pass names from the end of the TransformProgram.""" tape_transforms = [] pass_pipeline = [] - for t in transform_program: - if t.pass_name: - pass_pipeline.append(Pass(t.pass_name, *t.args, **t.kwargs)) - else: - tape_transforms.append(t) - return qml.transforms.core.TransformProgram(tape_transforms), tuple(pass_pipeline) \ No newline at end of file + i = len(transform_program) + for t in reversed(transform_program): + if t.pass_name is None: + break + i -= 1 + pass_pipeline = transform_program[i:] + tape_transforms = transform_program[:i] + for t in tape_transforms: + if t.transform is None: + raise ValueError( + f"{t} without a tape definition occurs before tape transform {tape_transforms[-1]}." + ) + return qml.transforms.core.TransformProgram(tape_transforms), tuple(pass_pipeline) From e885b911592494f7d576194a60d192a812957ccb Mon Sep 17 00:00:00 2001 From: albi3ro Date: Fri, 14 Nov 2025 14:23:15 -0500 Subject: [PATCH 06/24] some test fixes --- frontend/catalyst/from_plxpr/from_plxpr.py | 9 +++++---- frontend/catalyst/qfunc.py | 2 +- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/frontend/catalyst/from_plxpr/from_plxpr.py b/frontend/catalyst/from_plxpr/from_plxpr.py index 13336f288e..45361b945f 100644 --- a/frontend/catalyst/from_plxpr/from_plxpr.py +++ b/frontend/catalyst/from_plxpr/from_plxpr.py @@ -279,7 +279,7 @@ def register_transform(pl_transform, pass_name, decomposition): transforms_to_passes[pl_transform] = (pass_name, decomposition) -def _handle_decompose_transform(self, inner_jaxpr, consts, non_const_args, targs, tkwargs): +def _handle_decompose_transform(self, inner_jaxpr, consts, non_const_args, tkwargs): if not self.requires_decompose_lowering: self.requires_decompose_lowering = True else: @@ -303,7 +303,7 @@ def _handle_decompose_transform(self, inner_jaxpr, consts, non_const_args, targs # Add the decompose-lowering pass to the start of the pipeline t = qml.transform(pass_name="decompose-lowering") - pass_container = qml.transforms.core.TransformContainer(t, args=targs, kwargs=tkwargs) + pass_container = qml.transforms.core.TransformContainer(t) next_eval._pass_pipeline.insert(0, pass_container) # We still need to construct and solve the graph based on @@ -346,7 +346,7 @@ def handle_transform( and qml.decomposition.enabled_graph() ): return _handle_decompose_transform( - self, inner_jaxpr, consts, non_const_args, targs, tkwargs + self, inner_jaxpr, consts, non_const_args, tkwargs ) catalyst_pass_name = transform.pass_name @@ -373,7 +373,8 @@ def wrapper(*args): # Apply the corresponding Catalyst pass counterpart next_eval = copy(self) - bound_pass = qml.transforms.core.TransformContainer(transform, args=targs, kwargs=tkwargs) + t = qml.transform(pass_name=catalyst_pass_name) + bound_pass = qml.transforms.core.TransformContainer(t, args=targs, kwargs=tkwargs) next_eval._pass_pipeline.insert(0, bound_pass) return next_eval.eval(inner_jaxpr, consts, *non_const_args) diff --git a/frontend/catalyst/qfunc.py b/frontend/catalyst/qfunc.py index dbca8c649b..ae63ff2c5f 100644 --- a/frontend/catalyst/qfunc.py +++ b/frontend/catalyst/qfunc.py @@ -285,7 +285,7 @@ def __call__(self, *args, **kwargs): new_transform_program, new_pipeline = _extract_passes(self.transform_program) # Update the qnode with peephole pipeline - old_pipeline = kwargs.pop("pass_pipeline", ()) or () + old_pipeline = tuple(kwargs.pop("pass_pipeline", ()) or ()) pass_pipeline = old_pipeline + new_pipeline pass_pipeline = dictionary_to_list_of_passes(pass_pipeline) new_qnode = copy(self) From 5c99bbadc836987fb081200250a3e26f1ba05a67 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Mon, 17 Nov 2025 10:45:04 -0500 Subject: [PATCH 07/24] fix failing test --- frontend/catalyst/from_plxpr/from_plxpr.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/frontend/catalyst/from_plxpr/from_plxpr.py b/frontend/catalyst/from_plxpr/from_plxpr.py index 45361b945f..d8d060a64c 100644 --- a/frontend/catalyst/from_plxpr/from_plxpr.py +++ b/frontend/catalyst/from_plxpr/from_plxpr.py @@ -48,7 +48,6 @@ qdealloc_p, quantum_kernel_p, ) -from catalyst.passes.pass_api import Pass from .qfunc_interpreter import PLxPRToQuantumJaxprInterpreter from .qubit_handler import ( @@ -215,7 +214,9 @@ def handle_qnode( # Fallback to the legacy decomposition if the graph-based decomposition failed if not graph_succeeded: # Remove the decompose-lowering pass from the pipeline - self._pass_pipeline = [p for p in self._pass_pipeline if p.name != "decompose-lowering"] + self._pass_pipeline = [ + p for p in self._pass_pipeline if p.pass_name != "decompose-lowering" + ] closed_jaxpr = _apply_compiler_decompose_to_plxpr( inner_jaxpr=closed_jaxpr.jaxpr, consts=closed_jaxpr.consts, @@ -345,9 +346,7 @@ def handle_transform( and transform._plxpr_transform.__name__ == "decompose_plxpr_to_plxpr" and qml.decomposition.enabled_graph() ): - return _handle_decompose_transform( - self, inner_jaxpr, consts, non_const_args, tkwargs - ) + return _handle_decompose_transform(self, inner_jaxpr, consts, non_const_args, tkwargs) catalyst_pass_name = transform.pass_name if catalyst_pass_name is None: From ffedfe4a05a8dbf18305f13ea5a1e7e0cece7bb0 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Mon, 17 Nov 2025 14:38:50 -0500 Subject: [PATCH 08/24] see if that fixes the failure --- frontend/catalyst/qfunc.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/frontend/catalyst/qfunc.py b/frontend/catalyst/qfunc.py index ae63ff2c5f..75a1d27018 100644 --- a/frontend/catalyst/qfunc.py +++ b/frontend/catalyst/qfunc.py @@ -285,9 +285,9 @@ def __call__(self, *args, **kwargs): new_transform_program, new_pipeline = _extract_passes(self.transform_program) # Update the qnode with peephole pipeline - old_pipeline = tuple(kwargs.pop("pass_pipeline", ()) or ()) - pass_pipeline = old_pipeline + new_pipeline - pass_pipeline = dictionary_to_list_of_passes(pass_pipeline) + old_pipeline = kwargs.pop("pass_pipeline") + processed_old_pipeline = tuple(dictionary_to_list_of_passes(old_pipeline)) + pass_pipeline = processed_old_pipeline + new_pipeline new_qnode = copy(self) new_qnode._transform_program = new_transform_program # pylint: disable=protected-access From 77a211d9b6aa91ce2c50c89cd508d08fb8a24b67 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Mon, 17 Nov 2025 15:00:34 -0500 Subject: [PATCH 09/24] oops --- frontend/catalyst/qfunc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frontend/catalyst/qfunc.py b/frontend/catalyst/qfunc.py index 75a1d27018..944418a036 100644 --- a/frontend/catalyst/qfunc.py +++ b/frontend/catalyst/qfunc.py @@ -285,7 +285,7 @@ def __call__(self, *args, **kwargs): new_transform_program, new_pipeline = _extract_passes(self.transform_program) # Update the qnode with peephole pipeline - old_pipeline = kwargs.pop("pass_pipeline") + old_pipeline = kwargs.pop("pass_pipeline", None) processed_old_pipeline = tuple(dictionary_to_list_of_passes(old_pipeline)) pass_pipeline = processed_old_pipeline + new_pipeline new_qnode = copy(self) From a1abd24d02db5885997b58425876c6dd339c8f4a Mon Sep 17 00:00:00 2001 From: albi3ro Date: Mon, 17 Nov 2025 18:44:27 -0500 Subject: [PATCH 10/24] [skip ci] starting to test --- frontend/catalyst/qfunc.py | 2 +- .../test/lit/test_peephole_optimizations.py | 34 +++++++++++++++++++ .../pytest/test_peephole_optimizations.py | 30 +++++++++++++--- 3 files changed, 61 insertions(+), 5 deletions(-) diff --git a/frontend/catalyst/qfunc.py b/frontend/catalyst/qfunc.py index 944418a036..ea564ac043 100644 --- a/frontend/catalyst/qfunc.py +++ b/frontend/catalyst/qfunc.py @@ -43,7 +43,7 @@ from catalyst.jax_primitives import quantum_kernel_p from catalyst.jax_tracer import Function, trace_quantum_function from catalyst.logging import debug_logger -from catalyst.passes.pass_api import Pass, dictionary_to_list_of_passes +from catalyst.passes.pass_api import dictionary_to_list_of_passes from catalyst.tracing.contexts import EvaluationContext from catalyst.tracing.type_signatures import filter_static_args from catalyst.utils.exceptions import CompileError diff --git a/frontend/test/lit/test_peephole_optimizations.py b/frontend/test/lit/test_peephole_optimizations.py index 40a882e035..bffec18fe0 100644 --- a/frontend/test/lit/test_peephole_optimizations.py +++ b/frontend/test/lit/test_peephole_optimizations.py @@ -86,6 +86,40 @@ def test_pipeline_lowering_workflow(x): test_pipeline_lowering() +def test_transform_lowering(): + """ + Basic pipeline lowering on one qnode. + """ + @qjit(keep_intermediate=True) + @qml.transforms.merge_rotations + @qml.transforms.cancel_inverses + @qml.qnode(qml.device("lightning.qubit", wires=2)) + def test_pipeline_lowering_workflow(x): + qml.RX(x, wires=[0]) + qml.Hadamard(wires=[1]) + qml.Hadamard(wires=[1]) + return qml.expval(qml.PauliY(wires=0)) + + # CHECK: pipeline=(remove-chained-self-inverse, merge-rotations) + print_jaxpr(test_pipeline_lowering_workflow, 1.2) + + # CHECK: transform.named_sequence @__transform_main + # CHECK-NEXT: {{%.+}} = transform.apply_registered_pass "remove-chained-self-inverse" to {{%.+}} + # CHECK-NEXT: {{%.+}} = transform.apply_registered_pass "merge-rotations" to {{%.+}} + # CHECK-NEXT: transform.yield + print_mlir(test_pipeline_lowering_workflow, 1.2) + + # CHECK: {{%.+}} = call @test_pipeline_lowering_workflow_0( + # CHECK: func.func public @test_pipeline_lowering_workflow_0( + # CHECK: {{%.+}} = quantum.custom "RX"({{%.+}}) {{%.+}} : !quantum.bit + # CHECK-NOT: {{%.+}} = quantum.custom "Hadamard"() {{%.+}} : !quantum.bit + # CHECK-NOT: {{%.+}} = quantum.custom "Hadamard"() {{%.+}} : !quantum.bit + test_pipeline_lowering_workflow(42.42) + flush_peephole_opted_mlir_to_iostream(test_pipeline_lowering_workflow) + + +test_transform_lowering() + def test_pipeline_lowering_keep_original(): """ diff --git a/frontend/test/pytest/test_peephole_optimizations.py b/frontend/test/pytest/test_peephole_optimizations.py index a99d9283ab..4c3809d9f6 100644 --- a/frontend/test/pytest/test_peephole_optimizations.py +++ b/frontend/test/pytest/test_peephole_optimizations.py @@ -38,7 +38,9 @@ ### Test peephole pass decorators preserve functionality of circuits ### @pytest.mark.parametrize("theta", [42.42]) -def test_cancel_inverses_functionality(theta, backend): +# should be able to get rid of catalyst.passes.cancel_inverses soon, but testing both for now. +@pytest.mark.parametrize("cancel_inverses_version", (cancel_inverses, qml.transforms.cancel_inverses)) +def test_cancel_inverses_functionality(theta, backend, cancel_inverses_version): def circuit(x): qml.RX(x, wires=0) @@ -50,14 +52,15 @@ def circuit(x): customized_device = qml.device(backend, wires=1) qjitted_workflow = qjit(qml.QNode(circuit, customized_device)) - optimized_workflow = qjit(cancel_inverses(qml.QNode(circuit, customized_device))) + optimized_workflow = qjit(cancel_inverses_version(qml.QNode(circuit, customized_device))) assert np.allclose(reference_workflow(theta), qjitted_workflow(theta)) assert np.allclose(reference_workflow(theta), optimized_workflow(theta)) @pytest.mark.parametrize("theta", [42.42]) -def test_merge_rotation_functionality(theta, backend): +@pytest.mark.parametrize("merge_rotations_version", (merge_rotations, qml.transforms.merge_rotations)) +def test_merge_rotation_functionality(theta, backend, merge_rotations_version): def circuit(x): qml.RX(x, wires=0) @@ -76,7 +79,7 @@ def circuit(x): customized_device = qml.device(backend, wires=1) qjitted_workflow = qjit(qml.QNode(circuit, customized_device)) - optimized_workflow = qjit(merge_rotations(qml.QNode(circuit, customized_device))) + optimized_workflow = qjit(merge_rotations_version(qml.QNode(circuit, customized_device))) assert np.allclose(reference_workflow(theta), qjitted_workflow(theta)) assert np.allclose(reference_workflow(theta), optimized_workflow(theta)) @@ -202,6 +205,25 @@ def test_chained_apply_passes_workflow(x: float): assert "remove-chained-self-inverse" in test_chained_apply_passes_workflow.mlir assert "merge-rotations" in test_chained_apply_passes_workflow.mlir +def test_chained_transforms(): + """ + Test that chained transforms are present in the transform passes. + """ + + @qjit + @qml.transforms.merge_rotations + @qml.transforms.cancel_inverses + @qml.qnode(qml.device("lightning.qubit", wires=2)) + def test_chained_apply_passes_workflow(x: float): + qml.Hadamard(wires=[1]) + qml.RX(x, wires=[0]) + qml.RX(-x, wires=[0]) + qml.Hadamard(wires=[1]) + return qml.expval(qml.PauliY(wires=0)) + + assert "remove-chained-self-inverse" in test_chained_apply_passes_workflow.mlir + assert "merge-rotations" in test_chained_apply_passes_workflow.mlir + def test_disentangle_passes(): """ From b6441bfc7c2447c320fe2deefbca3a64735c1723 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Tue, 18 Nov 2025 14:29:14 -0500 Subject: [PATCH 11/24] try using transform instead of passes --- frontend/catalyst/passes/builtin_passes.py | 96 +++++++++------------- 1 file changed, 38 insertions(+), 58 deletions(-) diff --git a/frontend/catalyst/passes/builtin_passes.py b/frontend/catalyst/passes/builtin_passes.py index 2c809ea0f9..cae0901442 100644 --- a/frontend/catalyst/passes/builtin_passes.py +++ b/frontend/catalyst/passes/builtin_passes.py @@ -17,6 +17,7 @@ import copy import functools import json +from pennylane import transform from catalyst.compiler import _options_to_cli_flags, _quantum_opt from catalyst.passes.pass_api import PassPipelineWrapper @@ -136,7 +137,7 @@ def circuit(x: float): %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs %3 = quantum.expval %2 : f64 """ - return PassPipelineWrapper(qnode, "remove-chained-self-inverse") + return transform(pass_name="remove-chained-self-inverse")(qnode) def disentangle_cnot(qnode): @@ -225,7 +226,7 @@ def circuit(): %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit %out_qubits_0 = quantum.custom "PauliX"() %2 : !quantum.bit """ - return PassPipelineWrapper(qnode, "disentangle-CNOT") + return transform(pass_name="disentangle-CNOT")(qnode) def disentangle_swap(qnode): @@ -325,7 +326,7 @@ def circuit(): %out_qubits_2:2 = quantum.custom "CNOT"() %out_qubits_1, %out_qubits : !quantum.bit, !quantum.bit %out_qubits_3:2 = quantum.custom "CNOT"() %out_qubits_2#1, %out_qubits_2#0 : !quantum.bit, !quantum.bit """ - return PassPipelineWrapper(qnode, "disentangle-SWAP") + return transform(pass_name="disentangle-SWAP")(qnode) def merge_rotations(qnode): @@ -391,7 +392,7 @@ def circuit(x: float): >>> circuit(0.54) Array(0.5965506257017892, dtype=float64) """ - return PassPipelineWrapper(qnode, "merge-rotations") + return transform(pass_name="merge-rotations")(qnode) def decompose_lowering(qnode): @@ -410,7 +411,7 @@ def decompose_lowering(qnode): // TODO: add example here """ - return PassPipelineWrapper(qnode, "decompose-lowering") # pragma: no cover + return transform(pass_name="decompose-lowering")(qnode) def ions_decomposition(qnode): # pragma: nocover @@ -532,7 +533,7 @@ def circuit(): %out_qubits_8 = quantum.custom "RY"(%cst_2) %out_qubits_6#1 : !quantum.bit %out_qubits_9 = quantum.custom "RY"(%cst_2) %out_qubits_7 : !quantum.bit """ - return PassPipelineWrapper(qnode, "ions-decomposition") + return transform(pass_name="ions-decomposition")(qnode) def to_ppr(qnode): @@ -612,8 +613,7 @@ def circuit(): . . . """ - return PassPipelineWrapper(qnode, "to-ppr") - + return transform(pass_name="to-ppr")(qnode) def commute_ppr(qnode=None, *, max_pauli_size=0): R""" @@ -711,8 +711,7 @@ def circuit(): if qnode is None: return functools.partial(commute_ppr, max_pauli_size=max_pauli_size) - commute_ppr_pass = {"commute_ppr": {"max-pauli-size": max_pauli_size}} - return PassPipelineWrapper(qnode, commute_ppr_pass) + return transform(pass_name="commute_ppr")(qnode, max_pauli_size=max_pauli_size) def merge_ppr_ppm(qnode=None, *, max_pauli_size=0): @@ -800,8 +799,7 @@ def circuit(): if qnode is None: return functools.partial(merge_ppr_ppm, max_pauli_size=max_pauli_size) - merge_ppr_ppm_pass = {"merge_ppr_ppm": {"max-pauli-size": max_pauli_size}} - return PassPipelineWrapper(qnode, merge_ppr_ppm_pass) + return transform(pass_name="merge_ppr_ppm")(qnode, max_pauli_size=max_pauli_size) def ppr_to_ppm(qnode=None, *, decompose_method="pauli-corrected", avoid_y_measure=False): @@ -883,19 +881,13 @@ def circuit(): . . . """ - passes = { - "ppr_to_ppm": { - "decompose-method": decompose_method, - "avoid-y-measure": avoid_y_measure, - }, - } if qnode is None: return functools.partial( ppr_to_ppm, decompose_method=decompose_method, avoid_y_measure=avoid_y_measure ) - return PassPipelineWrapper(qnode, passes) + return transform(pass_name="ppr_to_ppm")(qnode, decompose_method=decompose_method, avoid_y_measure=avoid_y_measure) def ppm_compilation( @@ -996,13 +988,6 @@ def circuit(): . . . """ - passes = { - "ppm-compilation": { - "decompose-method": decompose_method, - "avoid-y-measure": avoid_y_measure, - "max-pauli-size": max_pauli_size, - } - } if qnode is None: return functools.partial( @@ -1012,8 +997,7 @@ def circuit(): max_pauli_size=max_pauli_size, ) - return PassPipelineWrapper(qnode, passes) - + return transform(pass_name="ppm-compilation")(qnode, decompose_method=decompose_method, avoid_y_measure=avoid_y_measure, max_pauli_size=max_pauli_size) def ppm_specs(fn): R""" @@ -1082,34 +1066,31 @@ def loop(i): . . . """ - - if fn.mlir_module is not None: - # aot mode - new_options = copy.copy(fn.compile_options) - if new_options.pipelines is None: - raise CompileError("No pipeline found") - - # add ppm-spec pass at the end to existing pipeline - _, pass_list = new_options.pipelines[0] # first pipeline runs the user passes - # check if ppm-specs is already in the pass list - if "ppm-specs" not in pass_list: # pragma: nocover - pass_list.append("ppm-specs") - - new_options = _options_to_cli_flags(new_options) - raw_result = _quantum_opt(*new_options, [], stdin=str(fn.mlir_module)) - - try: - return json.loads( - raw_result[: raw_result.index("module")] - ) # remove MLIR starting with substring "module..." - except Exception as e: # pragma: nocover - raise CompileError( - "Invalid json format encountered in ppm_specs. " - f"Expected valid JSON but got {raw_result[: raw_result.index('module')]}" - ) from e - - else: + if fn.mlir_module is None: raise NotImplementedError("PPM passes only support AOT (Ahead-Of-Time) compilation mode.") + # aot mode + new_options = copy.copy(fn.compile_options) + if new_options.pipelines is None: + raise CompileError("No pipeline found") + + # add ppm-spec pass at the end to existing pipeline + _, pass_list = new_options.pipelines[0] # first pipeline runs the user passes + # check if ppm-specs is already in the pass list + if "ppm-specs" not in pass_list: # pragma: nocover + pass_list.append("ppm-specs") + + new_options = _options_to_cli_flags(new_options) + raw_result = _quantum_opt(*new_options, [], stdin=str(fn.mlir_module)) + + try: + return json.loads( + raw_result[: raw_result.index("module")] + ) # remove MLIR starting with substring "module..." + except Exception as e: # pragma: nocover + raise CompileError( + "Invalid json format encountered in ppm_specs. " + f"Expected valid JSON but got {raw_result[: raw_result.index('module')]}" + ) from e def reduce_t_depth(qnode): @@ -1191,8 +1172,7 @@ def circuit(): . . . """ - - return PassPipelineWrapper(qnode, "reduce-t-depth") + return transform(pass_name="reduce-t-depth")(qnode) def ppr_to_mbqc(qnode): @@ -1281,4 +1261,4 @@ def circuit(): ... """ - return PassPipelineWrapper(qnode, "ppr-to-mbqc") + return transform(pass_name="ppr-to-mbqc")(qnode) From 838e45f4cf181d47faf376fcf5e57c46c6eff713 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Tue, 18 Nov 2025 15:06:31 -0500 Subject: [PATCH 12/24] switch passes to being tranfsorms --- frontend/catalyst/passes/builtin_passes.py | 6 +++--- frontend/test/pytest/test_peephole_optimizations.py | 1 + 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/frontend/catalyst/passes/builtin_passes.py b/frontend/catalyst/passes/builtin_passes.py index cae0901442..67425afaea 100644 --- a/frontend/catalyst/passes/builtin_passes.py +++ b/frontend/catalyst/passes/builtin_passes.py @@ -711,7 +711,7 @@ def circuit(): if qnode is None: return functools.partial(commute_ppr, max_pauli_size=max_pauli_size) - return transform(pass_name="commute_ppr")(qnode, max_pauli_size=max_pauli_size) + return transform(pass_name="commute-ppr")(qnode, max_pauli_size=max_pauli_size) def merge_ppr_ppm(qnode=None, *, max_pauli_size=0): @@ -799,7 +799,7 @@ def circuit(): if qnode is None: return functools.partial(merge_ppr_ppm, max_pauli_size=max_pauli_size) - return transform(pass_name="merge_ppr_ppm")(qnode, max_pauli_size=max_pauli_size) + return transform(pass_name="merge-ppr-ppm")(qnode, max_pauli_size=max_pauli_size) def ppr_to_ppm(qnode=None, *, decompose_method="pauli-corrected", avoid_y_measure=False): @@ -887,7 +887,7 @@ def circuit(): ppr_to_ppm, decompose_method=decompose_method, avoid_y_measure=avoid_y_measure ) - return transform(pass_name="ppr_to_ppm")(qnode, decompose_method=decompose_method, avoid_y_measure=avoid_y_measure) + return transform(pass_name="ppr-to-ppm")(qnode, decompose_method=decompose_method, avoid_y_measure=avoid_y_measure) def ppm_compilation( diff --git a/frontend/test/pytest/test_peephole_optimizations.py b/frontend/test/pytest/test_peephole_optimizations.py index 4c3809d9f6..8cde675798 100644 --- a/frontend/test/pytest/test_peephole_optimizations.py +++ b/frontend/test/pytest/test_peephole_optimizations.py @@ -347,6 +347,7 @@ def f(): return f() + print(test_merge_ppr_ppm_workflow.mlir) assert 'transform.apply_registered_pass "merge-ppr-ppm"' in test_merge_ppr_ppm_workflow.mlir optimized_ir = test_merge_ppr_ppm_workflow.mlir_opt assert 'transform.apply_registered_pass "merge-ppr-ppm"' not in optimized_ir From b2ca54dacc35fa9cd50ba1dcb39a1ff655736f3d Mon Sep 17 00:00:00 2001 From: albi3ro Date: Tue, 18 Nov 2025 15:37:06 -0500 Subject: [PATCH 13/24] update apply_pass and apply_pass_plugin --- frontend/catalyst/passes/builtin_passes.py | 1 - frontend/catalyst/passes/pass_api.py | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/frontend/catalyst/passes/builtin_passes.py b/frontend/catalyst/passes/builtin_passes.py index 67425afaea..8aa364cfd6 100644 --- a/frontend/catalyst/passes/builtin_passes.py +++ b/frontend/catalyst/passes/builtin_passes.py @@ -20,7 +20,6 @@ from pennylane import transform from catalyst.compiler import _options_to_cli_flags, _quantum_opt -from catalyst.passes.pass_api import PassPipelineWrapper from catalyst.utils.exceptions import CompileError # pylint: disable=line-too-long, too-many-lines diff --git a/frontend/catalyst/passes/pass_api.py b/frontend/catalyst/passes/pass_api.py index 68be25c4da..ecd92db0f3 100644 --- a/frontend/catalyst/passes/pass_api.py +++ b/frontend/catalyst/passes/pass_api.py @@ -204,7 +204,7 @@ def module(): """ def decorator(qnode): - return PassPipelineWrapper(qnode, pass_name, *flags, **valued_options) + return qml.transform(pass_name=pass_name)(qnode, *flags, **valued_options) return decorator @@ -244,6 +244,7 @@ def module(): raise FileNotFoundError(f"File '{path_to_plugin}' does not exist.") def decorator(qnode): + return qml.transform(pass_name=pass_name)(qnode, *flags, **valued_options) return PassPipelineWrapper(qnode, pass_name, *flags, **valued_options) return decorator From f76ac1bfb68bb1834e7314f5d28d0c8a08553ef2 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Tue, 18 Nov 2025 15:37:51 -0500 Subject: [PATCH 14/24] update apply_pass and apply_pass_plugin --- frontend/catalyst/passes/pass_api.py | 1 - 1 file changed, 1 deletion(-) diff --git a/frontend/catalyst/passes/pass_api.py b/frontend/catalyst/passes/pass_api.py index ecd92db0f3..27fb02a353 100644 --- a/frontend/catalyst/passes/pass_api.py +++ b/frontend/catalyst/passes/pass_api.py @@ -245,7 +245,6 @@ def module(): def decorator(qnode): return qml.transform(pass_name=pass_name)(qnode, *flags, **valued_options) - return PassPipelineWrapper(qnode, pass_name, *flags, **valued_options) return decorator From 8b045d00777f7a85bf15fc47c0fa129faa997dd1 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Wed, 19 Nov 2025 14:11:40 -0500 Subject: [PATCH 15/24] adding in some tests --- frontend/catalyst/from_plxpr/from_plxpr.py | 2 - frontend/catalyst/jax_primitives_utils.py | 6 +- frontend/catalyst/qfunc.py | 3 +- .../from_plxpr/test_capture_integration.py | 27 ++++++- .../test/pytest/test_transform_pass_name.py | 80 +++++++++++++++++++ 5 files changed, 112 insertions(+), 6 deletions(-) create mode 100644 frontend/test/pytest/test_transform_pass_name.py diff --git a/frontend/catalyst/from_plxpr/from_plxpr.py b/frontend/catalyst/from_plxpr/from_plxpr.py index 03e3f4915d..1fe4965edc 100644 --- a/frontend/catalyst/from_plxpr/from_plxpr.py +++ b/frontend/catalyst/from_plxpr/from_plxpr.py @@ -264,12 +264,10 @@ def calling_convention(*args): # otherwise their value will be None. The second value indicates if the transform # requires decomposition to be supported by Catalyst. transforms_to_passes = { - pl_cancel_inverses: ("cancel-inverses", False), pl_commute_controlled: (None, False), pl_decompose: (None, False), pl_map_wires: (None, False), pl_merge_amplitude_embedding: (None, True), - pl_merge_rotations: ("merge-rotations", False), pl_single_qubit_fusion: (None, False), pl_unitary_to_rot: (None, False), } diff --git a/frontend/catalyst/jax_primitives_utils.py b/frontend/catalyst/jax_primitives_utils.py index d9e753efe2..19a9cd05e8 100644 --- a/frontend/catalyst/jax_primitives_utils.py +++ b/frontend/catalyst/jax_primitives_utils.py @@ -320,8 +320,10 @@ def __exit__(self, exc_type, exc_val, exc_tb): self.ctx.module_context = self.old_module_context -def _lowered_options(kwargs): +def _lowered_options(args, kwargs): lowered_options = {} + for arg in args: + lowered_options[str(arg)] = get_mlir_attribute_from_pyval(True) for option, value in kwargs.items(): mlir_option = str(option).replace("_", "-") lowered_options[mlir_option] = get_mlir_attribute_from_pyval(value) @@ -375,7 +377,7 @@ def transform_named_sequence_lowering(jax_ctx: mlir.LoweringRuleContext, pipelin target = bb_named_sequence.arguments[0] for _pass in pipeline: if isinstance(_pass, qml.transforms.core.TransformContainer): - options = _lowered_options(_pass.kwargs) + options = _lowered_options(_pass.args, _pass.kwargs) name = _pass.pass_name else: options = _pass.get_options() diff --git a/frontend/catalyst/qfunc.py b/frontend/catalyst/qfunc.py index 37a5b70b3e..b0af042dbe 100644 --- a/frontend/catalyst/qfunc.py +++ b/frontend/catalyst/qfunc.py @@ -291,7 +291,8 @@ def __call__(self, *args, **kwargs): processed_old_pipeline = tuple(dictionary_to_list_of_passes(old_pipeline)) pass_pipeline = processed_old_pipeline + new_pipeline new_qnode = copy(self) - new_qnode._transform_program = new_transform_program # pylint: disable=protected-access + # pylint: disable=attribute-defined-outside-init, protected-access + new_qnode._transform_program = new_transform_program # Mid-circuit measurement configuration/execution fn_result = configure_mcm_and_try_one_shot(new_qnode, args, kwargs, pass_pipeline) diff --git a/frontend/test/pytest/from_plxpr/test_capture_integration.py b/frontend/test/pytest/from_plxpr/test_capture_integration.py index ef6f9f370d..b0e3ede226 100644 --- a/frontend/test/pytest/from_plxpr/test_capture_integration.py +++ b/frontend/test/pytest/from_plxpr/test_capture_integration.py @@ -1048,7 +1048,7 @@ def circuit(x: float): assert jnp.allclose(circuit(0.1), capture_result) @pytest.mark.usefixtures("use_capture") - def test_pass_with_options(self, backend): + def test_pass_with_options_patch(self, backend): """Test the integration for a circuit with a pass that takes in options.""" @qml.transform @@ -1058,6 +1058,31 @@ def my_pass(_tape, my_option=None, my_other_option=None): # pylint: disable=unu register_transform(my_pass, "my-pass", False) + @qjit(target="mlir") + @partial(my_pass, my_option="my_option_value", my_other_option=False) + @qml.qnode(qml.device(backend, wires=1)) + def captured_circuit(): + return qml.expval(qml.PauliZ(0)) + + capture_mlir = captured_circuit.mlir + assert 'transform.apply_registered_pass "my-pass"' in capture_mlir + assert ( + 'with options = {"my-option" = "my_option_value", "my-other-option" = false}' + in capture_mlir + ) + + @pytest.mark.usefixtures("use_capture") + def test_pass_with_options(self, backend): + """Test the integration for a circuit with a pass that takes in options.""" + + @qml.transform + def my_pass(_tape, my_option=None, my_other_option=None): # pylint: disable=unused-argument + """A dummy qml.transform.""" + return + + my_pass = qml.transform(pass_name="my-pass") + + @qjit(target="mlir") @partial(my_pass, my_option="my_option_value", my_other_option=False) @qml.qnode(qml.device(backend, wires=1)) diff --git a/frontend/test/pytest/test_transform_pass_name.py b/frontend/test/pytest/test_transform_pass_name.py new file mode 100644 index 0000000000..9c6bbed9ac --- /dev/null +++ b/frontend/test/pytest/test_transform_pass_name.py @@ -0,0 +1,80 @@ +# Copyright 2023 Xanadu Quantum Technologies Inc. + +# 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. +"""Testing use of transforms with pass name integrating with qnodes. +""" +import pytest +from functools import partial + +import pennylane as qml + + + +def test_pass_with_options(backend): + """Test the integration for a circuit with a pass that takes in options.""" + + my_pass = qml.transform(pass_name="my-pass") + + @qml.qjit(target="mlir") + @partial(my_pass, my_option="my_option_value", my_other_option=False) + @qml.qnode(qml.device(backend, wires=1)) + def captured_circuit(): + return qml.expval(qml.PauliZ(0)) + + capture_mlir = captured_circuit.mlir + assert 'transform.apply_registered_pass "my-pass"' in capture_mlir + assert ( + 'with options = {"my-option" = "my_option_value", "my-other-option" = false}' + in capture_mlir + ) + +def test_pass_before_tape_transform(backend): + """Test that provided an mlir-only transform prior to a tape transform raises an error.""" + + my_pass = qml.transform(pass_name="my-pass") + + @qml.transform + def tape_transform(tape): + return (tape, ), lambda x: x[0] + + @qml.qjit + @tape_transform + @my_pass + @qml.qnode(qml.device(backend, wires=1)) + def f(x): + return qml.state() + + with pytest.raises(ValueError, match="without a tape definition occurs before tape transform"): + f(0.5) + +def test_pass_after_tape_transform(backend): + """Test that passes can be applied after tape transforms.""" + + @qml.transform + def tape_only_cancel_inverses(tape): + return qml.transforms.cancel_inverses(tape) + + my_pass = qml.transform(pass_name="my-pass") + + @qml.qjit(target="mlir") + @my_pass + @tape_only_cancel_inverses + @qml.qnode(qml.device(backend, wires=1)) + def c(): + qml.X(0) + qml.X(0) + return qml.state() + + # check inverses canceled + assert 'quantum.custom "PauliX"()' not in c.mlir + assert 'transform.apply_registered_pass "my-pass"' in c.mlir \ No newline at end of file From ed528bafb04f3c74456ba03dc828167996433c84 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Wed, 19 Nov 2025 14:12:04 -0500 Subject: [PATCH 16/24] black and isort --- .../test/lit/test_peephole_optimizations.py | 2 ++ .../from_plxpr/test_capture_integration.py | 3 +-- .../test/pytest/test_peephole_optimizations.py | 9 +++++++-- .../test/pytest/test_transform_pass_name.py | 18 +++++++++--------- 4 files changed, 19 insertions(+), 13 deletions(-) diff --git a/frontend/test/lit/test_peephole_optimizations.py b/frontend/test/lit/test_peephole_optimizations.py index d9ec39c8cf..eac1009f86 100644 --- a/frontend/test/lit/test_peephole_optimizations.py +++ b/frontend/test/lit/test_peephole_optimizations.py @@ -86,10 +86,12 @@ def test_pipeline_lowering_workflow(x): test_pipeline_lowering() + def test_transform_lowering(): """ Basic pipeline lowering on one qnode. """ + @qjit(keep_intermediate=True) @qml.transforms.merge_rotations @qml.transforms.cancel_inverses diff --git a/frontend/test/pytest/from_plxpr/test_capture_integration.py b/frontend/test/pytest/from_plxpr/test_capture_integration.py index b0e3ede226..0447d41f44 100644 --- a/frontend/test/pytest/from_plxpr/test_capture_integration.py +++ b/frontend/test/pytest/from_plxpr/test_capture_integration.py @@ -1079,9 +1079,8 @@ def test_pass_with_options(self, backend): def my_pass(_tape, my_option=None, my_other_option=None): # pylint: disable=unused-argument """A dummy qml.transform.""" return - - my_pass = qml.transform(pass_name="my-pass") + my_pass = qml.transform(pass_name="my-pass") @qjit(target="mlir") @partial(my_pass, my_option="my_option_value", my_other_option=False) diff --git a/frontend/test/pytest/test_peephole_optimizations.py b/frontend/test/pytest/test_peephole_optimizations.py index c6e7783866..9cb1ffa221 100644 --- a/frontend/test/pytest/test_peephole_optimizations.py +++ b/frontend/test/pytest/test_peephole_optimizations.py @@ -39,7 +39,9 @@ ### Test peephole pass decorators preserve functionality of circuits ### @pytest.mark.parametrize("theta", [42.42]) # should be able to get rid of catalyst.passes.cancel_inverses soon, but testing both for now. -@pytest.mark.parametrize("cancel_inverses_version", (cancel_inverses, qml.transforms.cancel_inverses)) +@pytest.mark.parametrize( + "cancel_inverses_version", (cancel_inverses, qml.transforms.cancel_inverses) +) def test_cancel_inverses_functionality(theta, backend, cancel_inverses_version): def circuit(x): @@ -59,7 +61,9 @@ def circuit(x): @pytest.mark.parametrize("theta", [42.42]) -@pytest.mark.parametrize("merge_rotations_version", (merge_rotations, qml.transforms.merge_rotations)) +@pytest.mark.parametrize( + "merge_rotations_version", (merge_rotations, qml.transforms.merge_rotations) +) def test_merge_rotation_functionality(theta, backend, merge_rotations_version): def circuit(x): @@ -206,6 +210,7 @@ def test_chained_apply_passes_workflow(x: float): assert "cancel-inverses" in mlir assert "merge-rotations" in mlir + def test_chained_transforms(): """ Test that chained transforms are present in the transform passes. diff --git a/frontend/test/pytest/test_transform_pass_name.py b/frontend/test/pytest/test_transform_pass_name.py index 9c6bbed9ac..54c9af0c2f 100644 --- a/frontend/test/pytest/test_transform_pass_name.py +++ b/frontend/test/pytest/test_transform_pass_name.py @@ -11,13 +11,11 @@ # 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. -"""Testing use of transforms with pass name integrating with qnodes. -""" -import pytest +"""Testing use of transforms with pass name integrating with qnodes.""" from functools import partial import pennylane as qml - +import pytest def test_pass_with_options(backend): @@ -38,14 +36,15 @@ def captured_circuit(): in capture_mlir ) + def test_pass_before_tape_transform(backend): """Test that provided an mlir-only transform prior to a tape transform raises an error.""" my_pass = qml.transform(pass_name="my-pass") - + @qml.transform def tape_transform(tape): - return (tape, ), lambda x: x[0] + return (tape,), lambda x: x[0] @qml.qjit @tape_transform @@ -57,13 +56,14 @@ def f(x): with pytest.raises(ValueError, match="without a tape definition occurs before tape transform"): f(0.5) + def test_pass_after_tape_transform(backend): """Test that passes can be applied after tape transforms.""" @qml.transform def tape_only_cancel_inverses(tape): return qml.transforms.cancel_inverses(tape) - + my_pass = qml.transform(pass_name="my-pass") @qml.qjit(target="mlir") @@ -74,7 +74,7 @@ def c(): qml.X(0) qml.X(0) return qml.state() - + # check inverses canceled assert 'quantum.custom "PauliX"()' not in c.mlir - assert 'transform.apply_registered_pass "my-pass"' in c.mlir \ No newline at end of file + assert 'transform.apply_registered_pass "my-pass"' in c.mlir From ec38c77a9b0c38634d806dda557d1783f7d5f06e Mon Sep 17 00:00:00 2001 From: albi3ro Date: Thu, 20 Nov 2025 11:03:48 -0500 Subject: [PATCH 17/24] minor fixes --- frontend/catalyst/from_plxpr/from_plxpr.py | 2 -- frontend/test/pytest/from_plxpr/test_capture_integration.py | 5 ----- frontend/test/pytest/test_peephole_optimizations.py | 2 +- 3 files changed, 1 insertion(+), 8 deletions(-) diff --git a/frontend/catalyst/from_plxpr/from_plxpr.py b/frontend/catalyst/from_plxpr/from_plxpr.py index 1fe4965edc..1adb6e546a 100644 --- a/frontend/catalyst/from_plxpr/from_plxpr.py +++ b/frontend/catalyst/from_plxpr/from_plxpr.py @@ -30,11 +30,9 @@ from pennylane.capture.primitives import jacobian_prim as pl_jac_prim from pennylane.capture.primitives import transform_prim from pennylane.ops.functions.map_wires import _map_wires_transform as pl_map_wires -from pennylane.transforms import cancel_inverses as pl_cancel_inverses from pennylane.transforms import commute_controlled as pl_commute_controlled from pennylane.transforms import decompose as pl_decompose from pennylane.transforms import merge_amplitude_embedding as pl_merge_amplitude_embedding -from pennylane.transforms import merge_rotations as pl_merge_rotations from pennylane.transforms import single_qubit_fusion as pl_single_qubit_fusion from pennylane.transforms import unitary_to_rot as pl_unitary_to_rot diff --git a/frontend/test/pytest/from_plxpr/test_capture_integration.py b/frontend/test/pytest/from_plxpr/test_capture_integration.py index 0447d41f44..b8daa65016 100644 --- a/frontend/test/pytest/from_plxpr/test_capture_integration.py +++ b/frontend/test/pytest/from_plxpr/test_capture_integration.py @@ -1075,11 +1075,6 @@ def captured_circuit(): def test_pass_with_options(self, backend): """Test the integration for a circuit with a pass that takes in options.""" - @qml.transform - def my_pass(_tape, my_option=None, my_other_option=None): # pylint: disable=unused-argument - """A dummy qml.transform.""" - return - my_pass = qml.transform(pass_name="my-pass") @qjit(target="mlir") diff --git a/frontend/test/pytest/test_peephole_optimizations.py b/frontend/test/pytest/test_peephole_optimizations.py index 9cb1ffa221..e21aa8dbbe 100644 --- a/frontend/test/pytest/test_peephole_optimizations.py +++ b/frontend/test/pytest/test_peephole_optimizations.py @@ -227,7 +227,7 @@ def test_chained_apply_passes_workflow(x: float): qml.Hadamard(wires=[1]) return qml.expval(qml.PauliY(wires=0)) - assert "remove-chained-self-inverse" in test_chained_apply_passes_workflow.mlir + assert "cancel-inverses" in test_chained_apply_passes_workflow.mlir assert "merge-rotations" in test_chained_apply_passes_workflow.mlir From 47710692d0eb888e1d670bd8c7c5e2bfdf9b6018 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Thu, 20 Nov 2025 11:15:12 -0500 Subject: [PATCH 18/24] remove tests --- .../pytest/test_peephole_optimizations.py | 43 ------------------- 1 file changed, 43 deletions(-) diff --git a/frontend/test/pytest/test_peephole_optimizations.py b/frontend/test/pytest/test_peephole_optimizations.py index c9c1ce1678..6db6276da6 100644 --- a/frontend/test/pytest/test_peephole_optimizations.py +++ b/frontend/test/pytest/test_peephole_optimizations.py @@ -147,49 +147,6 @@ def f(x): assert np.allclose(res[0], res[1]) -### Test bad usages of pass decorators ### -def test_passes_bad_usages(): - """ - Tests that an error is raised when cancel_inverses is not used properly - """ - - def test_passes_not_on_qnode(): - def classical_func(): - return 42.42 - - with pytest.raises( - TypeError, - match="A QNode is expected, got the classical function", - ): - pipeline({})(classical_func) - - with pytest.raises( - TypeError, - match="A QNode is expected, got the classical function", - ): - cancel_inverses(classical_func) - - with pytest.raises( - TypeError, - match="A QNode is expected, got the classical function", - ): - merge_rotations(classical_func) - - with pytest.raises( - TypeError, - match="A QNode is expected, got the classical function", - ): - disentangle_cnot(classical_func) - - with pytest.raises( - TypeError, - match="A QNode is expected, got the classical function", - ): - disentangle_swap(classical_func) - - test_passes_not_on_qnode() - - def test_chained_passes(): """ Test that chained passes are present in the transform passes. From b5595aff8bb478ca362a8899ef08704ecac878ef Mon Sep 17 00:00:00 2001 From: Christina Lee Date: Thu, 20 Nov 2025 11:19:05 -0500 Subject: [PATCH 19/24] Apply suggestion from @albi3ro --- frontend/test/pytest/test_peephole_optimizations.py | 1 - 1 file changed, 1 deletion(-) diff --git a/frontend/test/pytest/test_peephole_optimizations.py b/frontend/test/pytest/test_peephole_optimizations.py index 6db6276da6..3dc6b24bec 100644 --- a/frontend/test/pytest/test_peephole_optimizations.py +++ b/frontend/test/pytest/test_peephole_optimizations.py @@ -310,7 +310,6 @@ def f(): return f() - print(test_merge_ppr_ppm_workflow.mlir) assert 'transform.apply_registered_pass "merge-ppr-ppm"' in test_merge_ppr_ppm_workflow.mlir optimized_ir = test_merge_ppr_ppm_workflow.mlir_opt assert 'transform.apply_registered_pass "merge-ppr-ppm"' not in optimized_ir From 579c27b160f81b56b3c29f752ab99f64b7a8b1d1 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Thu, 20 Nov 2025 11:19:44 -0500 Subject: [PATCH 20/24] leave pipeline test in --- .../pytest/test_peephole_optimizations.py | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/frontend/test/pytest/test_peephole_optimizations.py b/frontend/test/pytest/test_peephole_optimizations.py index 6db6276da6..9983a48a36 100644 --- a/frontend/test/pytest/test_peephole_optimizations.py +++ b/frontend/test/pytest/test_peephole_optimizations.py @@ -147,6 +147,26 @@ def f(x): assert np.allclose(res[0], res[1]) +### Test bad usages of pass decorators ### +def test_passes_bad_usages(): + """ + Tests that an error is raised when cancel_inverses is not used properly + """ + + def test_passes_not_on_qnode(): + def classical_func(): + return 42.42 + + with pytest.raises( + TypeError, + match="A QNode is expected, got the classical function", + ): + pipeline({})(classical_func) + + + test_passes_not_on_qnode() + + def test_chained_passes(): """ Test that chained passes are present in the transform passes. From e01158e63f7a71be020074b97a00e92043a51d83 Mon Sep 17 00:00:00 2001 From: albi3ro Date: Thu, 20 Nov 2025 11:27:29 -0500 Subject: [PATCH 21/24] update name of cancel_inverses in test --- frontend/test/lit/test_peephole_optimizations.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frontend/test/lit/test_peephole_optimizations.py b/frontend/test/lit/test_peephole_optimizations.py index eac1009f86..b457eeded4 100644 --- a/frontend/test/lit/test_peephole_optimizations.py +++ b/frontend/test/lit/test_peephole_optimizations.py @@ -102,11 +102,11 @@ def test_pipeline_lowering_workflow(x): qml.Hadamard(wires=[1]) return qml.expval(qml.PauliY(wires=0)) - # CHECK: pipeline=(remove-chained-self-inverse, merge-rotations) + # CHECK: pipeline=(cancel-inverses, merge-rotations) print_jaxpr(test_pipeline_lowering_workflow, 1.2) # CHECK: transform.named_sequence @__transform_main - # CHECK-NEXT: {{%.+}} = transform.apply_registered_pass "remove-chained-self-inverse" to {{%.+}} + # CHECK-NEXT: {{%.+}} = transform.apply_registered_pass "cancel-inverses" to {{%.+}} # CHECK-NEXT: {{%.+}} = transform.apply_registered_pass "merge-rotations" to {{%.+}} # CHECK-NEXT: transform.yield print_mlir(test_pipeline_lowering_workflow, 1.2) From d37d89b3a94104f643ceec9b87eaf95e8f3dfb4d Mon Sep 17 00:00:00 2001 From: albi3ro Date: Thu, 20 Nov 2025 11:51:55 -0500 Subject: [PATCH 22/24] Try to fix the lit test again --- .../test/lit/test_peephole_optimizations.py | 2 +- global_wf_5/0_global_wf.mlir | 86 ++++++ .../1_EnforceRuntimeInvariantsPass.mlir | 50 ++++ global_wf_5/2_HLOLoweringPass.mlir | 50 ++++ global_wf_5/3_QuantumCompilationPass.mlir | 50 ++++ global_wf_5/4_BufferizationPass.mlir | 76 ++++++ global_wf_5/5_MLIRToLLVMDialect.mlir | 184 +++++++++++++ global_wf_5/6_llvm_ir.ll | 165 +++++++++++ global_wf_5/global_wf.o | Bin 0 -> 3848 bytes global_wf_6/0_global_wf.mlir | 85 ++++++ .../1_EnforceRuntimeInvariantsPass.mlir | 52 ++++ global_wf_6/2_HLOLoweringPass.mlir | 52 ++++ global_wf_6/3_QuantumCompilationPass.mlir | 52 ++++ global_wf_6/4_BufferizationPass.mlir | 78 ++++++ global_wf_6/5_MLIRToLLVMDialect.mlir | 188 +++++++++++++ global_wf_6/6_llvm_ir.ll | 170 ++++++++++++ global_wf_6/global_wf.o | Bin 0 -> 3904 bytes ...ncel_inverses_keep_original_workflow0.mlir | 43 +++ .../1_EnforceRuntimeInvariantsPass.mlir | 32 +++ .../2_HLOLoweringPass.mlir | 32 +++ .../3_QuantumCompilationPass.mlir | 32 +++ .../4_BufferizationPass.mlir | 46 ++++ .../5_MLIRToLLVMDialect.mlir | 115 ++++++++ .../6_llvm_ir.ll | 116 ++++++++ ..._cancel_inverses_keep_original_workflow0.o | Bin 0 -> 3320 bytes ...ncel_inverses_keep_original_workflow1.mlir | 44 +++ .../1_EnforceRuntimeInvariantsPass.mlir | 30 ++ .../2_HLOLoweringPass.mlir | 30 ++ .../3_QuantumCompilationPass.mlir | 30 ++ .../4_BufferizationPass.mlir | 44 +++ .../5_MLIRToLLVMDialect.mlir | 112 ++++++++ .../6_llvm_ir.ll | 112 ++++++++ ..._cancel_inverses_keep_original_workflow1.o | Bin 0 -> 3192 bytes ...ncel_inverses_keep_original_workflow2.mlir | 73 +++++ .../1_EnforceRuntimeInvariantsPass.mlir | 48 ++++ .../2_HLOLoweringPass.mlir | 48 ++++ .../3_QuantumCompilationPass.mlir | 48 ++++ .../4_BufferizationPass.mlir | 74 +++++ .../5_MLIRToLLVMDialect.mlir | 185 +++++++++++++ .../6_llvm_ir.ll | 167 ++++++++++++ ..._cancel_inverses_keep_original_workflow2.o | Bin 0 -> 3960 bytes ...s_lowering_transform_applied_workflow.mlir | 102 +++++++ .../1_EnforceRuntimeInvariantsPass.mlir | 65 +++++ .../2_HLOLoweringPass.mlir | 65 +++++ .../3_QuantumCompilationPass.mlir | 65 +++++ .../4_BufferizationPass.mlir | 102 +++++++ .../5_MLIRToLLVMDialect.mlir | 258 ++++++++++++++++++ .../6_llvm_ir.ll | 224 +++++++++++++++ ...rses_lowering_transform_applied_workflow.o | Bin 0 -> 4640 bytes ...eline_lowering_keep_original_workflow.mlir | 83 ++++++ .../1_EnforceRuntimeInvariantsPass.mlir | 51 ++++ .../2_HLOLoweringPass.mlir | 51 ++++ .../3_QuantumCompilationPass.mlir | 51 ++++ .../4_BufferizationPass.mlir | 76 ++++++ .../5_MLIRToLLVMDialect.mlir | 191 +++++++++++++ .../6_llvm_ir.ll | 175 ++++++++++++ ...pipeline_lowering_keep_original_workflow.o | Bin 0 -> 3880 bytes .../0_test_pipeline_lowering_workflow.mlir | 49 ++++ .../1_EnforceRuntimeInvariantsPass.mlir | 31 +++ .../2_HLOLoweringPass.mlir | 31 +++ .../3_QuantumCompilationPass.mlir | 31 +++ .../4_BufferizationPass.mlir | 44 +++ .../5_MLIRToLLVMDialect.mlir | 116 ++++++++ .../6_llvm_ir.ll | 118 ++++++++ .../test_pipeline_lowering_workflow.o | Bin 0 -> 3104 bytes .../0_test_pipeline_lowering_workflow.mlir | 49 ++++ .../1_EnforceRuntimeInvariantsPass.mlir | 31 +++ .../2_HLOLoweringPass.mlir | 31 +++ .../3_QuantumCompilationPass.mlir | 31 +++ .../4_BufferizationPass.mlir | 44 +++ .../5_MLIRToLLVMDialect.mlir | 116 ++++++++ .../6_llvm_ir.ll | 118 ++++++++ .../test_pipeline_lowering_workflow.o | Bin 0 -> 3104 bytes 73 files changed, 5199 insertions(+), 1 deletion(-) create mode 100644 global_wf_5/0_global_wf.mlir create mode 100644 global_wf_5/1_EnforceRuntimeInvariantsPass.mlir create mode 100644 global_wf_5/2_HLOLoweringPass.mlir create mode 100644 global_wf_5/3_QuantumCompilationPass.mlir create mode 100644 global_wf_5/4_BufferizationPass.mlir create mode 100644 global_wf_5/5_MLIRToLLVMDialect.mlir create mode 100644 global_wf_5/6_llvm_ir.ll create mode 100644 global_wf_5/global_wf.o create mode 100644 global_wf_6/0_global_wf.mlir create mode 100644 global_wf_6/1_EnforceRuntimeInvariantsPass.mlir create mode 100644 global_wf_6/2_HLOLoweringPass.mlir create mode 100644 global_wf_6/3_QuantumCompilationPass.mlir create mode 100644 global_wf_6/4_BufferizationPass.mlir create mode 100644 global_wf_6/5_MLIRToLLVMDialect.mlir create mode 100644 global_wf_6/6_llvm_ir.ll create mode 100644 global_wf_6/global_wf.o create mode 100644 test_cancel_inverses_keep_original_workflow0_2/0_test_cancel_inverses_keep_original_workflow0.mlir create mode 100644 test_cancel_inverses_keep_original_workflow0_2/1_EnforceRuntimeInvariantsPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow0_2/2_HLOLoweringPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow0_2/3_QuantumCompilationPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow0_2/4_BufferizationPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow0_2/5_MLIRToLLVMDialect.mlir create mode 100644 test_cancel_inverses_keep_original_workflow0_2/6_llvm_ir.ll create mode 100644 test_cancel_inverses_keep_original_workflow0_2/test_cancel_inverses_keep_original_workflow0.o create mode 100644 test_cancel_inverses_keep_original_workflow1_2/0_test_cancel_inverses_keep_original_workflow1.mlir create mode 100644 test_cancel_inverses_keep_original_workflow1_2/1_EnforceRuntimeInvariantsPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow1_2/2_HLOLoweringPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow1_2/3_QuantumCompilationPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow1_2/4_BufferizationPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow1_2/5_MLIRToLLVMDialect.mlir create mode 100644 test_cancel_inverses_keep_original_workflow1_2/6_llvm_ir.ll create mode 100644 test_cancel_inverses_keep_original_workflow1_2/test_cancel_inverses_keep_original_workflow1.o create mode 100644 test_cancel_inverses_keep_original_workflow2_2/0_test_cancel_inverses_keep_original_workflow2.mlir create mode 100644 test_cancel_inverses_keep_original_workflow2_2/1_EnforceRuntimeInvariantsPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow2_2/2_HLOLoweringPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow2_2/3_QuantumCompilationPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow2_2/4_BufferizationPass.mlir create mode 100644 test_cancel_inverses_keep_original_workflow2_2/5_MLIRToLLVMDialect.mlir create mode 100644 test_cancel_inverses_keep_original_workflow2_2/6_llvm_ir.ll create mode 100644 test_cancel_inverses_keep_original_workflow2_2/test_cancel_inverses_keep_original_workflow2.o create mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/0_test_cancel_inverses_lowering_transform_applied_workflow.mlir create mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/1_EnforceRuntimeInvariantsPass.mlir create mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/2_HLOLoweringPass.mlir create mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/3_QuantumCompilationPass.mlir create mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/4_BufferizationPass.mlir create mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/5_MLIRToLLVMDialect.mlir create mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/6_llvm_ir.ll create mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/test_cancel_inverses_lowering_transform_applied_workflow.o create mode 100644 test_pipeline_lowering_keep_original_workflow_3/0_test_pipeline_lowering_keep_original_workflow.mlir create mode 100644 test_pipeline_lowering_keep_original_workflow_3/1_EnforceRuntimeInvariantsPass.mlir create mode 100644 test_pipeline_lowering_keep_original_workflow_3/2_HLOLoweringPass.mlir create mode 100644 test_pipeline_lowering_keep_original_workflow_3/3_QuantumCompilationPass.mlir create mode 100644 test_pipeline_lowering_keep_original_workflow_3/4_BufferizationPass.mlir create mode 100644 test_pipeline_lowering_keep_original_workflow_3/5_MLIRToLLVMDialect.mlir create mode 100644 test_pipeline_lowering_keep_original_workflow_3/6_llvm_ir.ll create mode 100644 test_pipeline_lowering_keep_original_workflow_3/test_pipeline_lowering_keep_original_workflow.o create mode 100644 test_pipeline_lowering_workflow_5/0_test_pipeline_lowering_workflow.mlir create mode 100644 test_pipeline_lowering_workflow_5/1_EnforceRuntimeInvariantsPass.mlir create mode 100644 test_pipeline_lowering_workflow_5/2_HLOLoweringPass.mlir create mode 100644 test_pipeline_lowering_workflow_5/3_QuantumCompilationPass.mlir create mode 100644 test_pipeline_lowering_workflow_5/4_BufferizationPass.mlir create mode 100644 test_pipeline_lowering_workflow_5/5_MLIRToLLVMDialect.mlir create mode 100644 test_pipeline_lowering_workflow_5/6_llvm_ir.ll create mode 100644 test_pipeline_lowering_workflow_5/test_pipeline_lowering_workflow.o create mode 100644 test_pipeline_lowering_workflow_6/0_test_pipeline_lowering_workflow.mlir create mode 100644 test_pipeline_lowering_workflow_6/1_EnforceRuntimeInvariantsPass.mlir create mode 100644 test_pipeline_lowering_workflow_6/2_HLOLoweringPass.mlir create mode 100644 test_pipeline_lowering_workflow_6/3_QuantumCompilationPass.mlir create mode 100644 test_pipeline_lowering_workflow_6/4_BufferizationPass.mlir create mode 100644 test_pipeline_lowering_workflow_6/5_MLIRToLLVMDialect.mlir create mode 100644 test_pipeline_lowering_workflow_6/6_llvm_ir.ll create mode 100644 test_pipeline_lowering_workflow_6/test_pipeline_lowering_workflow.o diff --git a/frontend/test/lit/test_peephole_optimizations.py b/frontend/test/lit/test_peephole_optimizations.py index b457eeded4..85e254cff6 100644 --- a/frontend/test/lit/test_peephole_optimizations.py +++ b/frontend/test/lit/test_peephole_optimizations.py @@ -102,7 +102,7 @@ def test_pipeline_lowering_workflow(x): qml.Hadamard(wires=[1]) return qml.expval(qml.PauliY(wires=0)) - # CHECK: pipeline=(cancel-inverses, merge-rotations) + # CHECK: pipeline=(, ) print_jaxpr(test_pipeline_lowering_workflow, 1.2) # CHECK: transform.named_sequence @__transform_main diff --git a/global_wf_5/0_global_wf.mlir b/global_wf_5/0_global_wf.mlir new file mode 100644 index 0000000000..68bd3dd410 --- /dev/null +++ b/global_wf_5/0_global_wf.mlir @@ -0,0 +1,86 @@ +module @global_wf { + func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.200000e+00> : tensor + %0 = catalyst.launch_kernel @module_g::@g(%cst) : (tensor) -> tensor + %1 = catalyst.launch_kernel @module_h::@h(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + module @module_g { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @g(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<2> : tensor + %0 = quantum.alloc( 2) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %c_3 = stablehlo.constant dense<1> : tensor + %extracted_4 = tensor.extract %c_3[] : tensor + %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit + %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %extracted_7 = tensor.extract %c[] : tensor + %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit + %extracted_8 = tensor.extract %c_3[] : tensor + %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + module @module_h { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @h(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<2> : tensor + %0 = quantum.alloc( 2) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %c_3 = stablehlo.constant dense<1> : tensor + %extracted_4 = tensor.extract %c_3[] : tensor + %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit + %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %extracted_7 = tensor.extract %c[] : tensor + %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit + %extracted_8 = tensor.extract %c_3[] : tensor + %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_5/1_EnforceRuntimeInvariantsPass.mlir b/global_wf_5/1_EnforceRuntimeInvariantsPass.mlir new file mode 100644 index 0000000000..92927083a9 --- /dev/null +++ b/global_wf_5/1_EnforceRuntimeInvariantsPass.mlir @@ -0,0 +1,50 @@ +module @global_wf { + func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.200000e+00> : tensor + %0 = call @g_0(%cst) : (tensor) -> tensor + %1 = call @h_0(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_5/2_HLOLoweringPass.mlir b/global_wf_5/2_HLOLoweringPass.mlir new file mode 100644 index 0000000000..1ac302c438 --- /dev/null +++ b/global_wf_5/2_HLOLoweringPass.mlir @@ -0,0 +1,50 @@ +module @global_wf { + func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.200000e+00> : tensor + %0 = call @g_0(%cst) : (tensor) -> tensor + %1 = call @h_0(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_5/3_QuantumCompilationPass.mlir b/global_wf_5/3_QuantumCompilationPass.mlir new file mode 100644 index 0000000000..1ac302c438 --- /dev/null +++ b/global_wf_5/3_QuantumCompilationPass.mlir @@ -0,0 +1,50 @@ +module @global_wf { + func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.200000e+00> : tensor + %0 = call @g_0(%cst) : (tensor) -> tensor + %1 = call @h_0(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_5/4_BufferizationPass.mlir b/global_wf_5/4_BufferizationPass.mlir new file mode 100644 index 0000000000..91c3f98f74 --- /dev/null +++ b/global_wf_5/4_BufferizationPass.mlir @@ -0,0 +1,76 @@ +module @global_wf { + memref.global "private" constant @__constant_xf64 : memref = dense<1.200000e+00> {alignment = 64 : i64} + func.func public @jit_global_wf() -> (memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(3735928559 : index) : i64 + %1 = memref.get_global @__constant_xf64 : memref + %2 = call @g_0(%1) : (memref) -> memref + %3 = call @h_0(%1) : (memref) -> memref + %4 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> + %5 = llvm.extractvalue %4[0] : !llvm.struct<(ptr, ptr, i64)> + %6 = llvm.ptrtoint %5 : !llvm.ptr to i64 + %7 = llvm.icmp "eq" %0, %6 : i64 + %8 = scf.if %7 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %2, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %2 : memref + } + %9 = builtin.unrealized_conversion_cast %3 : memref to !llvm.struct<(ptr, ptr, i64)> + %10 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> + %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 + %12 = llvm.icmp "eq" %0, %11 : i64 + %13 = scf.if %12 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %3, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %3 : memref + } + return %8, %13 : memref, memref + } + func.func public @g_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %5 = quantum.expval %4 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %5, %alloc[] : memref + %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit + quantum.dealloc %7 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func public @h_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %5 = quantum.expval %4 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %5, %alloc[] : memref + %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit + quantum.dealloc %7 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_5/5_MLIRToLLVMDialect.mlir b/global_wf_5/5_MLIRToLLVMDialect.mlir new file mode 100644 index 0000000000..e0522f0a2a --- /dev/null +++ b/global_wf_5/5_MLIRToLLVMDialect.mlir @@ -0,0 +1,184 @@ +module @global_wf { + llvm.func @__catalyst__rt__finalize() + llvm.func @__catalyst__rt__initialize(!llvm.ptr) + llvm.func @__catalyst__rt__device_release() + llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) + llvm.func @__catalyst__qis__Expval(i64) -> f64 + llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 + llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr + llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr + llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} + llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) + llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr + llvm.mlir.global private constant @__constant_xf64(1.200000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 + llvm.func @jit_global_wf() -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %1 = llvm.mlir.constant(0 : index) : i64 + %2 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %3 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr + %4 = llvm.mlir.constant(3735928559 : index) : i64 + %5 = llvm.mlir.constant(1 : index) : i64 + %6 = llvm.mlir.zero : !llvm.ptr + %7 = llvm.inttoptr %4 : i64 to !llvm.ptr + %8 = llvm.call @g_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %9 = llvm.call @h_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %10 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> + %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 + %12 = llvm.icmp "eq" %4, %11 : i64 + llvm.cond_br %12, ^bb1, ^bb2 + ^bb1: // pred: ^bb0 + %13 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %14 = llvm.ptrtoint %13 : !llvm.ptr to i64 + %15 = llvm.call @_mlir_memref_to_llvm_alloc(%14) : (i64) -> !llvm.ptr + %16 = llvm.insertvalue %15, %2[0] : !llvm.struct<(ptr, ptr, i64)> + %17 = llvm.insertvalue %15, %16[1] : !llvm.struct<(ptr, ptr, i64)> + %18 = llvm.insertvalue %1, %17[2] : !llvm.struct<(ptr, ptr, i64)> + %19 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %20 = llvm.ptrtoint %19 : !llvm.ptr to i64 + %21 = llvm.mul %20, %5 : i64 + %22 = llvm.extractvalue %8[1] : !llvm.struct<(ptr, ptr, i64)> + %23 = llvm.extractvalue %8[2] : !llvm.struct<(ptr, ptr, i64)> + %24 = llvm.getelementptr inbounds %22[%23] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%15, %24, %21) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb3(%18 : !llvm.struct<(ptr, ptr, i64)>) + ^bb2: // pred: ^bb0 + llvm.br ^bb3(%8 : !llvm.struct<(ptr, ptr, i64)>) + ^bb3(%25: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 + llvm.br ^bb4 + ^bb4: // pred: ^bb3 + %26 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> + %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 + %28 = llvm.icmp "eq" %4, %27 : i64 + llvm.cond_br %28, ^bb5, ^bb6 + ^bb5: // pred: ^bb4 + %29 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %30 = llvm.ptrtoint %29 : !llvm.ptr to i64 + %31 = llvm.call @_mlir_memref_to_llvm_alloc(%30) : (i64) -> !llvm.ptr + %32 = llvm.insertvalue %31, %2[0] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %1, %33[2] : !llvm.struct<(ptr, ptr, i64)> + %35 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %36 = llvm.ptrtoint %35 : !llvm.ptr to i64 + %37 = llvm.mul %36, %5 : i64 + %38 = llvm.extractvalue %9[1] : !llvm.struct<(ptr, ptr, i64)> + %39 = llvm.extractvalue %9[2] : !llvm.struct<(ptr, ptr, i64)> + %40 = llvm.getelementptr inbounds %38[%39] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%31, %40, %37) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb7(%34 : !llvm.struct<(ptr, ptr, i64)>) + ^bb6: // pred: ^bb4 + llvm.br ^bb7(%9 : !llvm.struct<(ptr, ptr, i64)>) + ^bb7(%41: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 + llvm.br ^bb8 + ^bb8: // pred: ^bb7 + %42 = llvm.insertvalue %25, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %43 = llvm.insertvalue %41, %42[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.return %43 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + } + llvm.func @_catalyst_pyface_jit_global_wf(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { + llvm.call @_catalyst_ciface_jit_global_wf(%arg0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @_catalyst_ciface_jit_global_wf(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.call @jit_global_wf() : () -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.store %0, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr + llvm.return + } + llvm.func internal @g_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(1 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(2 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr + %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 + %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 + %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 + %24 = llvm.add %23, %1 : i64 + %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr + %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 + %27 = llvm.sub %1, %2 : i64 + %28 = llvm.add %26, %27 : i64 + %29 = llvm.urem %28, %1 : i64 + %30 = llvm.sub %28, %29 : i64 + %31 = llvm.inttoptr %30 : i64 to !llvm.ptr + %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %21, %31 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func internal @h_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(1 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(2 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr + %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 + %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 + %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 + %24 = llvm.add %23, %1 : i64 + %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr + %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 + %27 = llvm.sub %1, %2 : i64 + %28 = llvm.add %26, %27 : i64 + %29 = llvm.urem %28, %1 : i64 + %30 = llvm.sub %28, %29 : i64 + %31 = llvm.inttoptr %30 : i64 to !llvm.ptr + %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %21, %31 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @setup() { + %0 = llvm.mlir.zero : !llvm.ptr + llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @teardown() { + llvm.call @__catalyst__rt__finalize() : () -> () + llvm.return + } +} \ No newline at end of file diff --git a/global_wf_5/6_llvm_ir.ll b/global_wf_5/6_llvm_ir.ll new file mode 100644 index 0000000000..b4b575588a --- /dev/null +++ b/global_wf_5/6_llvm_ir.ll @@ -0,0 +1,165 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" + +@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" +@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" +@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" +@__constant_xf64 = private constant double 1.200000e+00, align 64 + +declare void @__catalyst__rt__finalize() + +declare void @__catalyst__rt__initialize(ptr) + +declare void @__catalyst__rt__device_release() + +declare void @__catalyst__rt__qubit_release_array(ptr) + +declare double @__catalyst__qis__Expval(i64) + +declare i64 @__catalyst__qis__NamedObs(i64, ptr) + +declare void @__catalyst__qis__RX(double, ptr, ptr) + +declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) + +declare ptr @__catalyst__rt__qubit_allocate_array(i64) + +declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) + +declare ptr @_mlir_memref_to_llvm_alloc(i64) + +define { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_global_wf() { + %1 = call { ptr, ptr, i64 } @g_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) + %2 = call { ptr, ptr, i64 } @h_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) + %3 = extractvalue { ptr, ptr, i64 } %1, 0 + %4 = ptrtoint ptr %3 to i64 + %5 = icmp eq i64 3735928559, %4 + br i1 %5, label %6, label %14 + +6: ; preds = %0 + %7 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %8 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 + %9 = insertvalue { ptr, ptr, i64 } %8, ptr %7, 1 + %10 = insertvalue { ptr, ptr, i64 } %9, i64 0, 2 + %11 = extractvalue { ptr, ptr, i64 } %1, 1 + %12 = extractvalue { ptr, ptr, i64 } %1, 2 + %13 = getelementptr inbounds double, ptr %11, i64 %12 + call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %13, i64 8, i1 false) + br label %15 + +14: ; preds = %0 + br label %15 + +15: ; preds = %6, %14 + %16 = phi { ptr, ptr, i64 } [ %1, %14 ], [ %10, %6 ] + br label %17 + +17: ; preds = %15 + %18 = extractvalue { ptr, ptr, i64 } %2, 0 + %19 = ptrtoint ptr %18 to i64 + %20 = icmp eq i64 3735928559, %19 + br i1 %20, label %21, label %29 + +21: ; preds = %17 + %22 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %23 = insertvalue { ptr, ptr, i64 } poison, ptr %22, 0 + %24 = insertvalue { ptr, ptr, i64 } %23, ptr %22, 1 + %25 = insertvalue { ptr, ptr, i64 } %24, i64 0, 2 + %26 = extractvalue { ptr, ptr, i64 } %2, 1 + %27 = extractvalue { ptr, ptr, i64 } %2, 2 + %28 = getelementptr inbounds double, ptr %26, i64 %27 + call void @llvm.memcpy.p0.p0.i64(ptr %22, ptr %28, i64 8, i1 false) + br label %30 + +29: ; preds = %17 + br label %30 + +30: ; preds = %21, %29 + %31 = phi { ptr, ptr, i64 } [ %2, %29 ], [ %25, %21 ] + br label %32 + +32: ; preds = %30 + %33 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %16, 0 + %34 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %33, { ptr, ptr, i64 } %31, 1 + ret { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %34 +} + +define void @_catalyst_pyface_jit_global_wf(ptr %0, ptr %1) { + call void @_catalyst_ciface_jit_global_wf(ptr %0) + ret void +} + +define void @_catalyst_ciface_jit_global_wf(ptr %0) { + %2 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_global_wf() + store { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %2, ptr %0, align 8 + ret void +} + +define internal { ptr, ptr, i64 } @g_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) + %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) + %10 = call double @__catalyst__qis__Expval(i64 %9) + %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %12 = ptrtoint ptr %11 to i64 + %13 = add i64 %12, 63 + %14 = urem i64 %13, 64 + %15 = sub i64 %13, %14 + %16 = inttoptr i64 %15 to ptr + %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 + %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 + %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 + store double %10, ptr %16, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %19 +} + +define internal { ptr, ptr, i64 } @h_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) + %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) + %10 = call double @__catalyst__qis__Expval(i64 %9) + %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %12 = ptrtoint ptr %11 to i64 + %13 = add i64 %12, 63 + %14 = urem i64 %13, 64 + %15 = sub i64 %13, %14 + %16 = inttoptr i64 %15 to ptr + %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 + %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 + %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 + store double %10, ptr %16, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %19 +} + +define void @setup() { + call void @__catalyst__rt__initialize(ptr null) + ret void +} + +define void @teardown() { + call void @__catalyst__rt__finalize() + ret void +} + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 + +attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/global_wf_5/global_wf.o b/global_wf_5/global_wf.o new file mode 100644 index 0000000000000000000000000000000000000000..045e0e00841ab881f1401f526433e3cc32bf59f0 GIT binary patch literal 3848 zcmds4U2GIp6h6}}u;ph9QbdH%HJY>mmIX>gg$=9xnlwlN6CQ}S)9th!n4Mi_r=?3Z zZUQDIn%Ei>eL%C1l=$F-4;n~Z-*^L!5FRj@EhSm}NsRiyn5^|XGk4nEwu{jh6HjvI zn{&SNcki8@JA31gpZ{D=q!5HJ%^2Y(T%s6|br^4Ztf$Vq6c_uZPL6>D`V!pp;Cw7X z*xHEg-~0NB11C?+>cQQmkblSdIOX*)(H1r}Q-L86AyOGLH=9t1`g|psCoFrfEFzMv z1}W;0^QE(D$`(WBIo<3NqI-X>!*w|kM;d=YGA_}%)SoAA2p)J&v&+aqWnEn%oC_QDdfumiav#0>AGO zJ+va%YUElgdw_o#{*%Z%S;Kifw1Qg=`&x_;;+7z88M*gENq1^V(!I9~_Vw^-PolS^ zTOECQ0_#3r3W?j*(XS?WO{$|`UuJ#!0%1Rt2?sgYUP1h#HRLw0A~&>x+@= zU%_5s4qi?#4r^D&8cm{Rb#(s(=JUUv7w=X;Qm%dJJP9is^f*|LDk4< zTcRE2P+Ig3S*C8nxDAFgnq_K+F!9QQv{R`J62@b2x73z42_`9?Y0sTet6s=X6_(;f;Gn9nf;| ztY(^dLp3#F1eG{oMiFO+dUaa_3Ags;!Pd9%NUh70-}VMh1w8Z+c}fIUB59|UzG)sm z=Eu=<4fyMlztey(;z!2Ph#!#^+kCfq_1~42M*T@UDd&%oGO|%wxxAgC$i-*G)U+?b z9O-bRsC=S)%q?xe*n?4$K0zMZA6dyR%%8$2N?y*NkRuxKuY)g0Ue1sCqXB;je9t5J zYv7ZTm-DCE`gg%cB|o>nF|5lPqF4d=IPeq@IbtV)n0ss|a2@a&AkM&86o?$LHsE8x zX5cE|Pgo4r9pGBvP2g%^35X-V`x}DaUvp;nKa+$HWF8O2^Q z7NU)e_^yeRq|UekdQs|(=qFN;IwSgs^hli%^N1v+&WP`r2=~kR88P3;TO5SKfvBuw zl;ro@nB;@s={r&{0$FY$mi?pB|0-;(^Ww5_YA+v}WqFh1F-lU;vyS`Vdojm4VuSC! zbx6>P5xhrS&A*+WcS6@h9=`P9lL1^x!ZNmM!FYpc+O7c1@_3rRMQ3V?i%V zGc+~V(5X)w)>E3$P2H}~a8}O=aRdiq-z&X25(}JxBB$9yS;C(i)#}TfGZ%6k>Yc`UHeh6WRYRQXujNzvg8Xa(Zvpyo${PB4t-d5L4NpXGz{$DF6`3FF zt)m#waAX@=S~G2twJou|51wg5w?tY?TUx)cGr};2)52SS693KVU$@)dUL8A023z^B gp^Dx|`k&oNhMmrKdDk7@b-Q=nMq*IlGJp%@FYN<(vH$=8 literal 0 HcmV?d00001 diff --git a/global_wf_6/0_global_wf.mlir b/global_wf_6/0_global_wf.mlir new file mode 100644 index 0000000000..cc7499d896 --- /dev/null +++ b/global_wf_6/0_global_wf.mlir @@ -0,0 +1,85 @@ +module @global_wf { + func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.200000e+00> : tensor + %0 = catalyst.launch_kernel @module_g::@g(%cst) : (tensor) -> tensor + %1 = catalyst.launch_kernel @module_h::@h(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + module @module_g { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @g(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<2> : tensor + %0 = quantum.alloc( 2) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %c_3 = stablehlo.constant dense<1> : tensor + %extracted_4 = tensor.extract %c_3[] : tensor + %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit + %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %extracted_7 = tensor.extract %c[] : tensor + %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit + %extracted_8 = tensor.extract %c_3[] : tensor + %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + module @module_h { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "merge-rotations" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @h(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<2> : tensor + %0 = quantum.alloc( 2) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %c_3 = stablehlo.constant dense<1> : tensor + %extracted_4 = tensor.extract %c_3[] : tensor + %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit + %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %extracted_7 = tensor.extract %c[] : tensor + %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit + %extracted_8 = tensor.extract %c_3[] : tensor + %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_6/1_EnforceRuntimeInvariantsPass.mlir b/global_wf_6/1_EnforceRuntimeInvariantsPass.mlir new file mode 100644 index 0000000000..d29883c8f0 --- /dev/null +++ b/global_wf_6/1_EnforceRuntimeInvariantsPass.mlir @@ -0,0 +1,52 @@ +module @global_wf { + func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.200000e+00> : tensor + %0 = call @g_0(%cst) : (tensor) -> tensor + %1 = call @h_0(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_6/2_HLOLoweringPass.mlir b/global_wf_6/2_HLOLoweringPass.mlir new file mode 100644 index 0000000000..173b7cb80d --- /dev/null +++ b/global_wf_6/2_HLOLoweringPass.mlir @@ -0,0 +1,52 @@ +module @global_wf { + func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.200000e+00> : tensor + %0 = call @g_0(%cst) : (tensor) -> tensor + %1 = call @h_0(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_6/3_QuantumCompilationPass.mlir b/global_wf_6/3_QuantumCompilationPass.mlir new file mode 100644 index 0000000000..173b7cb80d --- /dev/null +++ b/global_wf_6/3_QuantumCompilationPass.mlir @@ -0,0 +1,52 @@ +module @global_wf { + func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.200000e+00> : tensor + %0 = call @g_0(%cst) : (tensor) -> tensor + %1 = call @h_0(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_6/4_BufferizationPass.mlir b/global_wf_6/4_BufferizationPass.mlir new file mode 100644 index 0000000000..3dcf4bb651 --- /dev/null +++ b/global_wf_6/4_BufferizationPass.mlir @@ -0,0 +1,78 @@ +module @global_wf { + memref.global "private" constant @__constant_xf64 : memref = dense<1.200000e+00> {alignment = 64 : i64} + func.func public @jit_global_wf() -> (memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(3735928559 : index) : i64 + %1 = memref.get_global @__constant_xf64 : memref + %2 = call @g_0(%1) : (memref) -> memref + %3 = call @h_0(%1) : (memref) -> memref + %4 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> + %5 = llvm.extractvalue %4[0] : !llvm.struct<(ptr, ptr, i64)> + %6 = llvm.ptrtoint %5 : !llvm.ptr to i64 + %7 = llvm.icmp "eq" %0, %6 : i64 + %8 = scf.if %7 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %2, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %2 : memref + } + %9 = builtin.unrealized_conversion_cast %3 : memref to !llvm.struct<(ptr, ptr, i64)> + %10 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> + %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 + %12 = llvm.icmp "eq" %0, %11 : i64 + %13 = scf.if %12 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %3, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %3 : memref + } + return %8, %13 : memref, memref + } + func.func public @g_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %5 = quantum.expval %4 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %5, %alloc[] : memref + %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit + quantum.dealloc %7 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func public @h_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %3 : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %5 = quantum.expval %4 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %5, %alloc[] : memref + %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %7 = quantum.insert %6[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %7 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/global_wf_6/5_MLIRToLLVMDialect.mlir b/global_wf_6/5_MLIRToLLVMDialect.mlir new file mode 100644 index 0000000000..5d5a0e433c --- /dev/null +++ b/global_wf_6/5_MLIRToLLVMDialect.mlir @@ -0,0 +1,188 @@ +module @global_wf { + llvm.func @__catalyst__rt__finalize() + llvm.func @__catalyst__rt__initialize(!llvm.ptr) + llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__device_release() + llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) + llvm.func @__catalyst__qis__Expval(i64) -> f64 + llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 + llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr + llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr + llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} + llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) + llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr + llvm.mlir.global private constant @__constant_xf64(1.200000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 + llvm.func @jit_global_wf() -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %1 = llvm.mlir.constant(0 : index) : i64 + %2 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %3 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr + %4 = llvm.mlir.constant(3735928559 : index) : i64 + %5 = llvm.mlir.constant(1 : index) : i64 + %6 = llvm.mlir.zero : !llvm.ptr + %7 = llvm.inttoptr %4 : i64 to !llvm.ptr + %8 = llvm.call @g_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %9 = llvm.call @h_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %10 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> + %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 + %12 = llvm.icmp "eq" %4, %11 : i64 + llvm.cond_br %12, ^bb1, ^bb2 + ^bb1: // pred: ^bb0 + %13 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %14 = llvm.ptrtoint %13 : !llvm.ptr to i64 + %15 = llvm.call @_mlir_memref_to_llvm_alloc(%14) : (i64) -> !llvm.ptr + %16 = llvm.insertvalue %15, %2[0] : !llvm.struct<(ptr, ptr, i64)> + %17 = llvm.insertvalue %15, %16[1] : !llvm.struct<(ptr, ptr, i64)> + %18 = llvm.insertvalue %1, %17[2] : !llvm.struct<(ptr, ptr, i64)> + %19 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %20 = llvm.ptrtoint %19 : !llvm.ptr to i64 + %21 = llvm.mul %20, %5 : i64 + %22 = llvm.extractvalue %8[1] : !llvm.struct<(ptr, ptr, i64)> + %23 = llvm.extractvalue %8[2] : !llvm.struct<(ptr, ptr, i64)> + %24 = llvm.getelementptr inbounds %22[%23] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%15, %24, %21) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb3(%18 : !llvm.struct<(ptr, ptr, i64)>) + ^bb2: // pred: ^bb0 + llvm.br ^bb3(%8 : !llvm.struct<(ptr, ptr, i64)>) + ^bb3(%25: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 + llvm.br ^bb4 + ^bb4: // pred: ^bb3 + %26 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> + %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 + %28 = llvm.icmp "eq" %4, %27 : i64 + llvm.cond_br %28, ^bb5, ^bb6 + ^bb5: // pred: ^bb4 + %29 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %30 = llvm.ptrtoint %29 : !llvm.ptr to i64 + %31 = llvm.call @_mlir_memref_to_llvm_alloc(%30) : (i64) -> !llvm.ptr + %32 = llvm.insertvalue %31, %2[0] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %1, %33[2] : !llvm.struct<(ptr, ptr, i64)> + %35 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %36 = llvm.ptrtoint %35 : !llvm.ptr to i64 + %37 = llvm.mul %36, %5 : i64 + %38 = llvm.extractvalue %9[1] : !llvm.struct<(ptr, ptr, i64)> + %39 = llvm.extractvalue %9[2] : !llvm.struct<(ptr, ptr, i64)> + %40 = llvm.getelementptr inbounds %38[%39] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%31, %40, %37) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb7(%34 : !llvm.struct<(ptr, ptr, i64)>) + ^bb6: // pred: ^bb4 + llvm.br ^bb7(%9 : !llvm.struct<(ptr, ptr, i64)>) + ^bb7(%41: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 + llvm.br ^bb8 + ^bb8: // pred: ^bb7 + %42 = llvm.insertvalue %25, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %43 = llvm.insertvalue %41, %42[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.return %43 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + } + llvm.func @_catalyst_pyface_jit_global_wf(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { + llvm.call @_catalyst_ciface_jit_global_wf(%arg0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @_catalyst_ciface_jit_global_wf(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.call @jit_global_wf() : () -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.store %0, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr + llvm.return + } + llvm.func internal @g_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(1 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(2 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr + %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 + %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 + %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 + %24 = llvm.add %23, %1 : i64 + %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr + %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 + %27 = llvm.sub %1, %2 : i64 + %28 = llvm.add %26, %27 : i64 + %29 = llvm.urem %28, %1 : i64 + %30 = llvm.sub %28, %29 : i64 + %31 = llvm.inttoptr %30 : i64 to !llvm.ptr + %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %21, %31 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func internal @h_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(1 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(2 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr + %20 = llvm.load %19 : !llvm.ptr -> !llvm.ptr + llvm.call @__catalyst__qis__Hadamard(%20, %4) : (!llvm.ptr, !llvm.ptr) -> () + llvm.call @__catalyst__qis__Hadamard(%20, %4) : (!llvm.ptr, !llvm.ptr) -> () + %21 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 + %22 = llvm.call @__catalyst__qis__Expval(%21) : (i64) -> f64 + %23 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %24 = llvm.ptrtoint %23 : !llvm.ptr to i64 + %25 = llvm.add %24, %1 : i64 + %26 = llvm.call @_mlir_memref_to_llvm_alloc(%25) : (i64) -> !llvm.ptr + %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 + %28 = llvm.sub %1, %2 : i64 + %29 = llvm.add %27, %28 : i64 + %30 = llvm.urem %29, %1 : i64 + %31 = llvm.sub %29, %30 : i64 + %32 = llvm.inttoptr %31 : i64 to !llvm.ptr + %33 = llvm.insertvalue %26, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %32, %33[1] : !llvm.struct<(ptr, ptr, i64)> + %35 = llvm.insertvalue %0, %34[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %22, %32 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %35 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @setup() { + %0 = llvm.mlir.zero : !llvm.ptr + llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @teardown() { + llvm.call @__catalyst__rt__finalize() : () -> () + llvm.return + } +} \ No newline at end of file diff --git a/global_wf_6/6_llvm_ir.ll b/global_wf_6/6_llvm_ir.ll new file mode 100644 index 0000000000..11cb9eb439 --- /dev/null +++ b/global_wf_6/6_llvm_ir.ll @@ -0,0 +1,170 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" + +@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" +@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" +@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" +@__constant_xf64 = private constant double 1.200000e+00, align 64 + +declare void @__catalyst__rt__finalize() + +declare void @__catalyst__rt__initialize(ptr) + +declare void @__catalyst__qis__Hadamard(ptr, ptr) + +declare void @__catalyst__rt__device_release() + +declare void @__catalyst__rt__qubit_release_array(ptr) + +declare double @__catalyst__qis__Expval(i64) + +declare i64 @__catalyst__qis__NamedObs(i64, ptr) + +declare void @__catalyst__qis__RX(double, ptr, ptr) + +declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) + +declare ptr @__catalyst__rt__qubit_allocate_array(i64) + +declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) + +declare ptr @_mlir_memref_to_llvm_alloc(i64) + +define { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_global_wf() { + %1 = call { ptr, ptr, i64 } @g_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) + %2 = call { ptr, ptr, i64 } @h_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) + %3 = extractvalue { ptr, ptr, i64 } %1, 0 + %4 = ptrtoint ptr %3 to i64 + %5 = icmp eq i64 3735928559, %4 + br i1 %5, label %6, label %14 + +6: ; preds = %0 + %7 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %8 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 + %9 = insertvalue { ptr, ptr, i64 } %8, ptr %7, 1 + %10 = insertvalue { ptr, ptr, i64 } %9, i64 0, 2 + %11 = extractvalue { ptr, ptr, i64 } %1, 1 + %12 = extractvalue { ptr, ptr, i64 } %1, 2 + %13 = getelementptr inbounds double, ptr %11, i64 %12 + call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %13, i64 8, i1 false) + br label %15 + +14: ; preds = %0 + br label %15 + +15: ; preds = %6, %14 + %16 = phi { ptr, ptr, i64 } [ %1, %14 ], [ %10, %6 ] + br label %17 + +17: ; preds = %15 + %18 = extractvalue { ptr, ptr, i64 } %2, 0 + %19 = ptrtoint ptr %18 to i64 + %20 = icmp eq i64 3735928559, %19 + br i1 %20, label %21, label %29 + +21: ; preds = %17 + %22 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %23 = insertvalue { ptr, ptr, i64 } poison, ptr %22, 0 + %24 = insertvalue { ptr, ptr, i64 } %23, ptr %22, 1 + %25 = insertvalue { ptr, ptr, i64 } %24, i64 0, 2 + %26 = extractvalue { ptr, ptr, i64 } %2, 1 + %27 = extractvalue { ptr, ptr, i64 } %2, 2 + %28 = getelementptr inbounds double, ptr %26, i64 %27 + call void @llvm.memcpy.p0.p0.i64(ptr %22, ptr %28, i64 8, i1 false) + br label %30 + +29: ; preds = %17 + br label %30 + +30: ; preds = %21, %29 + %31 = phi { ptr, ptr, i64 } [ %2, %29 ], [ %25, %21 ] + br label %32 + +32: ; preds = %30 + %33 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %16, 0 + %34 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %33, { ptr, ptr, i64 } %31, 1 + ret { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %34 +} + +define void @_catalyst_pyface_jit_global_wf(ptr %0, ptr %1) { + call void @_catalyst_ciface_jit_global_wf(ptr %0) + ret void +} + +define void @_catalyst_ciface_jit_global_wf(ptr %0) { + %2 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_global_wf() + store { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %2, ptr %0, align 8 + ret void +} + +define internal { ptr, ptr, i64 } @g_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) + %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) + %10 = call double @__catalyst__qis__Expval(i64 %9) + %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %12 = ptrtoint ptr %11 to i64 + %13 = add i64 %12, 63 + %14 = urem i64 %13, 64 + %15 = sub i64 %13, %14 + %16 = inttoptr i64 %15 to ptr + %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 + %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 + %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 + store double %10, ptr %16, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %19 +} + +define internal { ptr, ptr, i64 } @h_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) + %9 = load ptr, ptr %8, align 8 + call void @__catalyst__qis__Hadamard(ptr %9, ptr null) + call void @__catalyst__qis__Hadamard(ptr %9, ptr null) + %10 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) + %11 = call double @__catalyst__qis__Expval(i64 %10) + %12 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %13 = ptrtoint ptr %12 to i64 + %14 = add i64 %13, 63 + %15 = urem i64 %14, 64 + %16 = sub i64 %14, %15 + %17 = inttoptr i64 %16 to ptr + %18 = insertvalue { ptr, ptr, i64 } poison, ptr %12, 0 + %19 = insertvalue { ptr, ptr, i64 } %18, ptr %17, 1 + %20 = insertvalue { ptr, ptr, i64 } %19, i64 0, 2 + store double %11, ptr %17, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %20 +} + +define void @setup() { + call void @__catalyst__rt__initialize(ptr null) + ret void +} + +define void @teardown() { + call void @__catalyst__rt__finalize() + ret void +} + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 + +attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/global_wf_6/global_wf.o b/global_wf_6/global_wf.o new file mode 100644 index 0000000000000000000000000000000000000000..66050ae0428ca9794b9dee52ba519d778d49a7aa GIT binary patch literal 3904 zcmc&%Uu;uV82|3NLC2pCWH=GRYBU)EN`VnUp`i-MOcq=K6CQ|Xcimlg;r6z)cVlCi zG#L**>1Iew44OWfZSvrQ4%J-)o2z!r(_EroRD?AST8p%nuya5tlr2E8L}RY=hy+EAh^g{qYdO z(nc)z-IY%tJ9BzL_TFyz+&A{eE^qsZcJWdpWf{C7L@a4$790vu>n|_;_+{>;CL)=t z=b{GLUm~T(EHPwW)Xjb&x{p>X+?Ivda`6eAafkz}+&b|pJK!n^p$&?Gw3^U7xi-Hk z6Y{2JjFqI-G<#}-~=}FD=fmEdN6r_awdmt z!Gy}c9&_Uj-&Mw%r|q9U`9AmK&EK&t6N*BUMPK_2oL#jKQn}Dc<>G!S*V8HaXvRJm zEtd{M_Xu>4Q@I3xQ}EZW&@V~@o%So)leW*loqhhiAG)2<@?*9`oPw`;rikeuJ@<5* z0{ag5*@1XrDkGm(8~O$47ZIbHL(f|64sbiL9>&}ZyLQ;UOy$Ri5o11w=A}6t2Y=)l zIkdpn2KZ`|IY7Sv{UZDpt2ifz7H}J|-iGOe-AdT4rt%|Sv^={qT7I}1>zkp|9z|}^ za%Jr8Y4m+E?-TbbW8X}3Pby>IPO&^UPS_7++J+BaFTuWPBb6K1Q`xtc$_>p_R+_*m z1V3-U4>^A3jwrBeoGu_f>?SZLk=w*eKpdNiH-Qh)>xbyitgqeKhc0sWgmdLsPJXD_ ziHqD>CPL1fixREyx{W%w!LA_pvVi<-)W@8|w@}63ys+1HOSIyg57?Esmlc}yKf3gB z344Va9G{LIdRIV?iilYmJ35Ve+`7iOuBK`3DfH^s)v-)n*eCW~=s=Df5AWPhmYuq| zRT|4wZ?l=46i8E4LbDOLgK1=BLe9btQH8rEw0?tDbu_|N7u$OMl zd?xtsf_;1EV(~cv=ZvwAL@W{Ocs=-*YGkyX!47jMA^L{Wrfy!F{6GMh-CDTKZv~(sM8%*mNOE=YUPdXV7$5cx-Ml+Vs z%;B)1_k~lV)?m`?+_h(KIHOxy2*0@J)wq@kr!>`S@;BFv%g5%?VNS2TxZ8;Bl; z?gEipC=bLZK=&;dBR7D!U%S6{F~WB+J{h{NyBN6w_Th*17NCBY78BUqRLeQ6Rm*YYQ!URd(jQ->pIpShwn#p; zNS5abUfl5>04no?&u6tv;=kQg0w3_+Wh2s-koSdZ7)h*aLQSXDQT!LOtX5hxG&NIK zsb3q`W17%S-KzC)LC*+r0vBfgJAD}v%iNJ7qgg{K!aqN1x<7f*T*m&`NNQL$K+NZ# z8XZs(?;P&CxRLBr4RLXxnvdzr@(T`}1`Oa9HuOtcZAfkn7oykUWUaCzwYE;VU24CY zKryuxyLDPD;u>yyLrZ9;B~n&e>|xD>p{GScOQf{{VI_rO3@3!MH6;F@4~LqA;M8^U l3>m!2|5d8UePrO(ePmdPRHyUY>pb^3&)p;j1s-uc{sDLEle7Q; literal 0 HcmV?d00001 diff --git a/test_cancel_inverses_keep_original_workflow0_2/0_test_cancel_inverses_keep_original_workflow0.mlir b/test_cancel_inverses_keep_original_workflow0_2/0_test_cancel_inverses_keep_original_workflow0.mlir new file mode 100644 index 0000000000..aa764eebbe --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow0_2/0_test_cancel_inverses_keep_original_workflow0.mlir @@ -0,0 +1,43 @@ +module @test_cancel_inverses_keep_original_workflow0 { + func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> tensor attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.000000e+00> : tensor + %0 = catalyst.launch_kernel @module_f::@f(%cst) : (tensor) -> tensor + return %0 : tensor + } + module @module_f { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + transform.yield + } + } + func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<1> : tensor + %0 = quantum.alloc( 1) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit + %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %extracted_5 = tensor.extract %c[] : tensor + %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/1_EnforceRuntimeInvariantsPass.mlir b/test_cancel_inverses_keep_original_workflow0_2/1_EnforceRuntimeInvariantsPass.mlir new file mode 100644 index 0000000000..4fb48f93b0 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow0_2/1_EnforceRuntimeInvariantsPass.mlir @@ -0,0 +1,32 @@ +module @test_cancel_inverses_keep_original_workflow0 { + func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> tensor attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.000000e+00> : tensor + %0 = call @f_0(%cst) : (tensor) -> tensor + return %0 : tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/2_HLOLoweringPass.mlir b/test_cancel_inverses_keep_original_workflow0_2/2_HLOLoweringPass.mlir new file mode 100644 index 0000000000..b3a9f0361a --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow0_2/2_HLOLoweringPass.mlir @@ -0,0 +1,32 @@ +module @test_cancel_inverses_keep_original_workflow0 { + func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> tensor attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.000000e+00> : tensor + %0 = call @f_0(%cst) : (tensor) -> tensor + return %0 : tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/3_QuantumCompilationPass.mlir b/test_cancel_inverses_keep_original_workflow0_2/3_QuantumCompilationPass.mlir new file mode 100644 index 0000000000..b3a9f0361a --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow0_2/3_QuantumCompilationPass.mlir @@ -0,0 +1,32 @@ +module @test_cancel_inverses_keep_original_workflow0 { + func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> tensor attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.000000e+00> : tensor + %0 = call @f_0(%cst) : (tensor) -> tensor + return %0 : tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/4_BufferizationPass.mlir b/test_cancel_inverses_keep_original_workflow0_2/4_BufferizationPass.mlir new file mode 100644 index 0000000000..2b591faa52 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow0_2/4_BufferizationPass.mlir @@ -0,0 +1,46 @@ +module @test_cancel_inverses_keep_original_workflow0 { + memref.global "private" constant @__constant_xf64 : memref = dense<1.000000e+00> {alignment = 64 : i64} + func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> memref attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(3735928559 : index) : i64 + %1 = memref.get_global @__constant_xf64 : memref + %2 = call @f_0(%1) : (memref) -> memref + %3 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> + %4 = llvm.extractvalue %3[0] : !llvm.struct<(ptr, ptr, i64)> + %5 = llvm.ptrtoint %4 : !llvm.ptr to i64 + %6 = llvm.icmp "eq" %0, %5 : i64 + %7 = scf.if %6 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %2, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %2 : memref + } + return %7 : memref + } + func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %4 = quantum.expval %3 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %4, %alloc[] : memref + %5 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %5 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/5_MLIRToLLVMDialect.mlir b/test_cancel_inverses_keep_original_workflow0_2/5_MLIRToLLVMDialect.mlir new file mode 100644 index 0000000000..9e1d6c4310 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow0_2/5_MLIRToLLVMDialect.mlir @@ -0,0 +1,115 @@ +module @test_cancel_inverses_keep_original_workflow0 { + llvm.func @__catalyst__rt__finalize() + llvm.func @__catalyst__rt__initialize(!llvm.ptr) + llvm.func @__catalyst__rt__device_release() + llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) + llvm.func @__catalyst__qis__Expval(i64) -> f64 + llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 + llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr + llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr + llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} + llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) + llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr + llvm.mlir.global private constant @__constant_xf64(1.000000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 + llvm.func @jit_test_cancel_inverses_keep_original_workflow0() -> !llvm.struct<(ptr, ptr, i64)> attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %2 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr + %3 = llvm.mlir.constant(3735928559 : index) : i64 + %4 = llvm.mlir.constant(1 : index) : i64 + %5 = llvm.mlir.zero : !llvm.ptr + %6 = llvm.inttoptr %3 : i64 to !llvm.ptr + %7 = llvm.call @f_0(%6, %2, %0) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %8 = llvm.extractvalue %7[0] : !llvm.struct<(ptr, ptr, i64)> + %9 = llvm.ptrtoint %8 : !llvm.ptr to i64 + %10 = llvm.icmp "eq" %3, %9 : i64 + llvm.cond_br %10, ^bb1, ^bb2 + ^bb1: // pred: ^bb0 + %11 = llvm.getelementptr %5[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %12 = llvm.ptrtoint %11 : !llvm.ptr to i64 + %13 = llvm.call @_mlir_memref_to_llvm_alloc(%12) : (i64) -> !llvm.ptr + %14 = llvm.insertvalue %13, %1[0] : !llvm.struct<(ptr, ptr, i64)> + %15 = llvm.insertvalue %13, %14[1] : !llvm.struct<(ptr, ptr, i64)> + %16 = llvm.insertvalue %0, %15[2] : !llvm.struct<(ptr, ptr, i64)> + %17 = llvm.getelementptr %5[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %18 = llvm.ptrtoint %17 : !llvm.ptr to i64 + %19 = llvm.mul %18, %4 : i64 + %20 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64)> + %21 = llvm.extractvalue %7[2] : !llvm.struct<(ptr, ptr, i64)> + %22 = llvm.getelementptr inbounds %20[%21] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%13, %22, %19) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb3(%16 : !llvm.struct<(ptr, ptr, i64)>) + ^bb2: // pred: ^bb0 + llvm.br ^bb3(%7 : !llvm.struct<(ptr, ptr, i64)>) + ^bb3(%23: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 + llvm.br ^bb4 + ^bb4: // pred: ^bb3 + llvm.return %23 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow0(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { + llvm.call @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow0(%arg0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow0(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.call @jit_test_cancel_inverses_keep_original_workflow0() : () -> !llvm.struct<(ptr, ptr, i64)> + llvm.store %0, %arg0 : !llvm.struct<(ptr, ptr, i64)>, !llvm.ptr + llvm.return + } + llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(3 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(1 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () + llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 + %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 + %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 + %23 = llvm.add %22, %1 : i64 + %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr + %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 + %26 = llvm.sub %1, %2 : i64 + %27 = llvm.add %25, %26 : i64 + %28 = llvm.urem %27, %1 : i64 + %29 = llvm.sub %27, %28 : i64 + %30 = llvm.inttoptr %29 : i64 to !llvm.ptr + %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %20, %30 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @setup() { + %0 = llvm.mlir.zero : !llvm.ptr + llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @teardown() { + llvm.call @__catalyst__rt__finalize() : () -> () + llvm.return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/6_llvm_ir.ll b/test_cancel_inverses_keep_original_workflow0_2/6_llvm_ir.ll new file mode 100644 index 0000000000..13646634c3 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow0_2/6_llvm_ir.ll @@ -0,0 +1,116 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" + +@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" +@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" +@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" +@__constant_xf64 = private constant double 1.000000e+00, align 64 + +declare void @__catalyst__rt__finalize() + +declare void @__catalyst__rt__initialize(ptr) + +declare void @__catalyst__rt__device_release() + +declare void @__catalyst__rt__qubit_release_array(ptr) + +declare double @__catalyst__qis__Expval(i64) + +declare i64 @__catalyst__qis__NamedObs(i64, ptr) + +declare void @__catalyst__qis__Hadamard(ptr, ptr) + +declare void @__catalyst__qis__RX(double, ptr, ptr) + +declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) + +declare ptr @__catalyst__rt__qubit_allocate_array(i64) + +declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) + +declare ptr @_mlir_memref_to_llvm_alloc(i64) + +define { ptr, ptr, i64 } @jit_test_cancel_inverses_keep_original_workflow0() { + %1 = call { ptr, ptr, i64 } @f_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) + %2 = extractvalue { ptr, ptr, i64 } %1, 0 + %3 = ptrtoint ptr %2 to i64 + %4 = icmp eq i64 3735928559, %3 + br i1 %4, label %5, label %13 + +5: ; preds = %0 + %6 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %7 = insertvalue { ptr, ptr, i64 } poison, ptr %6, 0 + %8 = insertvalue { ptr, ptr, i64 } %7, ptr %6, 1 + %9 = insertvalue { ptr, ptr, i64 } %8, i64 0, 2 + %10 = extractvalue { ptr, ptr, i64 } %1, 1 + %11 = extractvalue { ptr, ptr, i64 } %1, 2 + %12 = getelementptr inbounds double, ptr %10, i64 %11 + call void @llvm.memcpy.p0.p0.i64(ptr %6, ptr %12, i64 8, i1 false) + br label %14 + +13: ; preds = %0 + br label %14 + +14: ; preds = %5, %13 + %15 = phi { ptr, ptr, i64 } [ %1, %13 ], [ %9, %5 ] + br label %16 + +16: ; preds = %14 + ret { ptr, ptr, i64 } %15 +} + +define void @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow0(ptr %0, ptr %1) { + call void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow0(ptr %0) + ret void +} + +define void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow0(ptr %0) { + %2 = call { ptr, ptr, i64 } @jit_test_cancel_inverses_keep_original_workflow0() + store { ptr, ptr, i64 } %2, ptr %0, align 8 + ret void +} + +define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + call void @__catalyst__qis__Hadamard(ptr %6, ptr null) + call void @__catalyst__qis__Hadamard(ptr %6, ptr null) + %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) + %9 = call double @__catalyst__qis__Expval(i64 %8) + %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %11 = ptrtoint ptr %10 to i64 + %12 = add i64 %11, 63 + %13 = urem i64 %12, 64 + %14 = sub i64 %12, %13 + %15 = inttoptr i64 %14 to ptr + %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 + %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 + %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 + store double %9, ptr %15, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %18 +} + +define void @setup() { + call void @__catalyst__rt__initialize(ptr null) + ret void +} + +define void @teardown() { + call void @__catalyst__rt__finalize() + ret void +} + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 + +attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_cancel_inverses_keep_original_workflow0_2/test_cancel_inverses_keep_original_workflow0.o b/test_cancel_inverses_keep_original_workflow0_2/test_cancel_inverses_keep_original_workflow0.o new file mode 100644 index 0000000000000000000000000000000000000000..910ae18dc939762033e8bdade9fd39e98d97f7ef GIT binary patch literal 3320 zcmc&$PiP!v6o1q0pG{jg(L`HqX;ykjk#09_MMN50HI*Df8)}3i;)^r-cO_v7C&}^;ydt2g0P+hy&Gr)_JN1b4p_(72P@+DV9%t~B!nmD zJhljz5Tj==jz-)T?o@F&9&h6a!Z{$&JVUgE$Q5mOD`0E9jEWOixfhVg?#Ou?cr4M2w4z$N4I3eH`g0ijrmT+>qn5_ zh&U162kj#&C{+Nb@H_|#%Xw;3#fP#y3%@|RmuMYA_|u58>Hsn!WlDfJ{(oH?SG2F| zm0ipJ_aA(-^zF?*aNL5X(c)UH_Xc8J^?RwddX#EweN?N$<~nS8HTp%{L8EbP{(>Ki zKf`uE_ho9;qnX-IF}mTycQw{=V+|B9Pp%)+;NOin2dL&Bq8iTV@nOFT`?X$BgARS@ z@w=fr0Qn)%9{BBpUngM?`MwPHnOePab{V-ZuEfOMdgb$F&Y@oU;yUviR|qv}%RYQr zUWMO|4ytLpz$2G>MZw>b0}}#b1j92Sb=RP)#Dvo@lk8N$~{F-s_0+5PK)s$ zF27$zA5lvXKk!4pR=Hm|zg`(!MqQh|;rGEdQGZ(d1>HlhN}rXpa(yo(U)4=l9#8h! z)0P;Uc5K6jupfdc>DbZ~Ha;0h&J}I>PQz)##zet`@x*I}HErr%(P>a(n||Guj+@RE z9K-btTThQT#ffxI_jI%DdP3SWY10@>m&#tDXrDfD@>JS2Jek55Kc!DdH(ippT{d-F z3Nt#19X1(pX?o1?L=^DEcp2K}6#fPG`-_p$t#G4ml}JjY_B zet3aUPaFN8O5g5$B`59j1=8k@XkGhzDT!Eo2i@NYS5yNHC9)rBAL8>MIt)4kT2VGp z92!h?u?_3r1T87Os*eyO8R_4KeqQN)?1MFw7>V@PAjm4cs*f7ue+GS~&H3x7`*EUF z75D`377#H~D?rqix(37?O1%ff9h%~qh#FFJz)qm4FbjMX{1EUl;2GcnU_Y=Mm;~Y; z9zGo6z(F8J!EjHA16@G;D2DfkIN&2^+~uh+fw;p{gFw#XFc6JRah)(7=6(VPmO|V; zuQ01HqcEuu!1lXWfVgLmFg}9PmK4v3IgyxGJR{CaWEIbdd=eSOGwub?d2u{OEJ{apRi23L{@xdzdts^*51bd>|AL^H=7k) zKps=WG%m{rHJpgiMyGOB6*c}Rx`kw#ReWI3A~7K`olI#-+Y=?v5hvNwG7U#q z(sE>8ctv5FGnNQiOXB|-bWJZZsO!Q-GFi(1!gb_6mw)bAGCiwwI(VK6o+nYu=Fg;5 z&g*!slNh6(#7xfVb`AsIuxBv2r7NbSEQz9HOz?{kvqfhrZx(0!8$;xbhYP`ZAy8iQ I<8uhsKgdedod5s; literal 0 HcmV?d00001 diff --git a/test_cancel_inverses_keep_original_workflow1_2/0_test_cancel_inverses_keep_original_workflow1.mlir b/test_cancel_inverses_keep_original_workflow1_2/0_test_cancel_inverses_keep_original_workflow1.mlir new file mode 100644 index 0000000000..89ffaa9043 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow1_2/0_test_cancel_inverses_keep_original_workflow1.mlir @@ -0,0 +1,44 @@ +module @test_cancel_inverses_keep_original_workflow1 { + func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> tensor attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.000000e+00> : tensor + %0 = catalyst.launch_kernel @module_f::@f(%cst) : (tensor) -> tensor + return %0 : tensor + } + module @module_f { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<1> : tensor + %0 = quantum.alloc( 1) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit + %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %extracted_5 = tensor.extract %c[] : tensor + %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/1_EnforceRuntimeInvariantsPass.mlir b/test_cancel_inverses_keep_original_workflow1_2/1_EnforceRuntimeInvariantsPass.mlir new file mode 100644 index 0000000000..b455d31e30 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow1_2/1_EnforceRuntimeInvariantsPass.mlir @@ -0,0 +1,30 @@ +module @test_cancel_inverses_keep_original_workflow1 { + func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> tensor attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.000000e+00> : tensor + %0 = call @f_0(%cst) : (tensor) -> tensor + return %0 : tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/2_HLOLoweringPass.mlir b/test_cancel_inverses_keep_original_workflow1_2/2_HLOLoweringPass.mlir new file mode 100644 index 0000000000..61a941fcc5 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow1_2/2_HLOLoweringPass.mlir @@ -0,0 +1,30 @@ +module @test_cancel_inverses_keep_original_workflow1 { + func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> tensor attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.000000e+00> : tensor + %0 = call @f_0(%cst) : (tensor) -> tensor + return %0 : tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/3_QuantumCompilationPass.mlir b/test_cancel_inverses_keep_original_workflow1_2/3_QuantumCompilationPass.mlir new file mode 100644 index 0000000000..61a941fcc5 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow1_2/3_QuantumCompilationPass.mlir @@ -0,0 +1,30 @@ +module @test_cancel_inverses_keep_original_workflow1 { + func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> tensor attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.000000e+00> : tensor + %0 = call @f_0(%cst) : (tensor) -> tensor + return %0 : tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/4_BufferizationPass.mlir b/test_cancel_inverses_keep_original_workflow1_2/4_BufferizationPass.mlir new file mode 100644 index 0000000000..8dc4bf2189 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow1_2/4_BufferizationPass.mlir @@ -0,0 +1,44 @@ +module @test_cancel_inverses_keep_original_workflow1 { + memref.global "private" constant @__constant_xf64 : memref = dense<1.000000e+00> {alignment = 64 : i64} + func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> memref attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(3735928559 : index) : i64 + %1 = memref.get_global @__constant_xf64 : memref + %2 = call @f_0(%1) : (memref) -> memref + %3 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> + %4 = llvm.extractvalue %3[0] : !llvm.struct<(ptr, ptr, i64)> + %5 = llvm.ptrtoint %4 : !llvm.ptr to i64 + %6 = llvm.icmp "eq" %0, %5 : i64 + %7 = scf.if %6 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %2, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %2 : memref + } + return %7 : memref + } + func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %4 = quantum.expval %3 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %4, %alloc[] : memref + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %5 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/5_MLIRToLLVMDialect.mlir b/test_cancel_inverses_keep_original_workflow1_2/5_MLIRToLLVMDialect.mlir new file mode 100644 index 0000000000..ba4768c6db --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow1_2/5_MLIRToLLVMDialect.mlir @@ -0,0 +1,112 @@ +module @test_cancel_inverses_keep_original_workflow1 { + llvm.func @__catalyst__rt__finalize() + llvm.func @__catalyst__rt__initialize(!llvm.ptr) + llvm.func @__catalyst__rt__device_release() + llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) + llvm.func @__catalyst__qis__Expval(i64) -> f64 + llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 + llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr + llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr + llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} + llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) + llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr + llvm.mlir.global private constant @__constant_xf64(1.000000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 + llvm.func @jit_test_cancel_inverses_keep_original_workflow1() -> !llvm.struct<(ptr, ptr, i64)> attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %2 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr + %3 = llvm.mlir.constant(3735928559 : index) : i64 + %4 = llvm.mlir.constant(1 : index) : i64 + %5 = llvm.mlir.zero : !llvm.ptr + %6 = llvm.inttoptr %3 : i64 to !llvm.ptr + %7 = llvm.call @f_0(%6, %2, %0) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %8 = llvm.extractvalue %7[0] : !llvm.struct<(ptr, ptr, i64)> + %9 = llvm.ptrtoint %8 : !llvm.ptr to i64 + %10 = llvm.icmp "eq" %3, %9 : i64 + llvm.cond_br %10, ^bb1, ^bb2 + ^bb1: // pred: ^bb0 + %11 = llvm.getelementptr %5[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %12 = llvm.ptrtoint %11 : !llvm.ptr to i64 + %13 = llvm.call @_mlir_memref_to_llvm_alloc(%12) : (i64) -> !llvm.ptr + %14 = llvm.insertvalue %13, %1[0] : !llvm.struct<(ptr, ptr, i64)> + %15 = llvm.insertvalue %13, %14[1] : !llvm.struct<(ptr, ptr, i64)> + %16 = llvm.insertvalue %0, %15[2] : !llvm.struct<(ptr, ptr, i64)> + %17 = llvm.getelementptr %5[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %18 = llvm.ptrtoint %17 : !llvm.ptr to i64 + %19 = llvm.mul %18, %4 : i64 + %20 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64)> + %21 = llvm.extractvalue %7[2] : !llvm.struct<(ptr, ptr, i64)> + %22 = llvm.getelementptr inbounds %20[%21] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%13, %22, %19) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb3(%16 : !llvm.struct<(ptr, ptr, i64)>) + ^bb2: // pred: ^bb0 + llvm.br ^bb3(%7 : !llvm.struct<(ptr, ptr, i64)>) + ^bb3(%23: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 + llvm.br ^bb4 + ^bb4: // pred: ^bb3 + llvm.return %23 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow1(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { + llvm.call @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow1(%arg0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow1(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.call @jit_test_cancel_inverses_keep_original_workflow1() : () -> !llvm.struct<(ptr, ptr, i64)> + llvm.store %0, %arg0 : !llvm.struct<(ptr, ptr, i64)>, !llvm.ptr + llvm.return + } + llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(3 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(1 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 + %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 + %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 + %23 = llvm.add %22, %1 : i64 + %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr + %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 + %26 = llvm.sub %1, %2 : i64 + %27 = llvm.add %25, %26 : i64 + %28 = llvm.urem %27, %1 : i64 + %29 = llvm.sub %27, %28 : i64 + %30 = llvm.inttoptr %29 : i64 to !llvm.ptr + %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %20, %30 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @setup() { + %0 = llvm.mlir.zero : !llvm.ptr + llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @teardown() { + llvm.call @__catalyst__rt__finalize() : () -> () + llvm.return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/6_llvm_ir.ll b/test_cancel_inverses_keep_original_workflow1_2/6_llvm_ir.ll new file mode 100644 index 0000000000..d7163e9805 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow1_2/6_llvm_ir.ll @@ -0,0 +1,112 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" + +@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" +@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" +@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" +@__constant_xf64 = private constant double 1.000000e+00, align 64 + +declare void @__catalyst__rt__finalize() + +declare void @__catalyst__rt__initialize(ptr) + +declare void @__catalyst__rt__device_release() + +declare void @__catalyst__rt__qubit_release_array(ptr) + +declare double @__catalyst__qis__Expval(i64) + +declare i64 @__catalyst__qis__NamedObs(i64, ptr) + +declare void @__catalyst__qis__RX(double, ptr, ptr) + +declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) + +declare ptr @__catalyst__rt__qubit_allocate_array(i64) + +declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) + +declare ptr @_mlir_memref_to_llvm_alloc(i64) + +define { ptr, ptr, i64 } @jit_test_cancel_inverses_keep_original_workflow1() { + %1 = call { ptr, ptr, i64 } @f_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) + %2 = extractvalue { ptr, ptr, i64 } %1, 0 + %3 = ptrtoint ptr %2 to i64 + %4 = icmp eq i64 3735928559, %3 + br i1 %4, label %5, label %13 + +5: ; preds = %0 + %6 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %7 = insertvalue { ptr, ptr, i64 } poison, ptr %6, 0 + %8 = insertvalue { ptr, ptr, i64 } %7, ptr %6, 1 + %9 = insertvalue { ptr, ptr, i64 } %8, i64 0, 2 + %10 = extractvalue { ptr, ptr, i64 } %1, 1 + %11 = extractvalue { ptr, ptr, i64 } %1, 2 + %12 = getelementptr inbounds double, ptr %10, i64 %11 + call void @llvm.memcpy.p0.p0.i64(ptr %6, ptr %12, i64 8, i1 false) + br label %14 + +13: ; preds = %0 + br label %14 + +14: ; preds = %5, %13 + %15 = phi { ptr, ptr, i64 } [ %1, %13 ], [ %9, %5 ] + br label %16 + +16: ; preds = %14 + ret { ptr, ptr, i64 } %15 +} + +define void @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow1(ptr %0, ptr %1) { + call void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow1(ptr %0) + ret void +} + +define void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow1(ptr %0) { + %2 = call { ptr, ptr, i64 } @jit_test_cancel_inverses_keep_original_workflow1() + store { ptr, ptr, i64 } %2, ptr %0, align 8 + ret void +} + +define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) + %9 = call double @__catalyst__qis__Expval(i64 %8) + %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %11 = ptrtoint ptr %10 to i64 + %12 = add i64 %11, 63 + %13 = urem i64 %12, 64 + %14 = sub i64 %12, %13 + %15 = inttoptr i64 %14 to ptr + %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 + %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 + %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 + store double %9, ptr %15, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %18 +} + +define void @setup() { + call void @__catalyst__rt__initialize(ptr null) + ret void +} + +define void @teardown() { + call void @__catalyst__rt__finalize() + ret void +} + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 + +attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_cancel_inverses_keep_original_workflow1_2/test_cancel_inverses_keep_original_workflow1.o b/test_cancel_inverses_keep_original_workflow1_2/test_cancel_inverses_keep_original_workflow1.o new file mode 100644 index 0000000000000000000000000000000000000000..5d5f22bd7a10bd2dc12699c992fde504c8073249 GIT binary patch literal 3192 zcmc&$T}&KR6h6}hx>#ILP^xXpHhqAYZkHcp)Rc5pYWhH0f|&Hdco~+vFlBajJ2U)j zR}&&W_z3>Q7d86`#0TGNA|{%U_)u$V(+5o!S`++B8lPN~6~8lc2bP6Rv@hP|&Nt_L z=bU@anVEa%#$Uhx-9)4j24Cth!-sH*Vq!dj`HshW;=W6P9Wc7s2P2RVHE(=w3v*1N9a-BI!Gt9YLw z9-apsA(~W_2fer+#q`U0a);tYS>F=&pH-oe=njTg?=Gt zFOKJjzHD$`uueHYu!8(|dcb{Wo1hQXeF3*`ToD93GoAyxH--9Hx?edXV%uQ<>WDLu8+;BP6@(=~YYfzx^oe%;>ysI3P7 zgW_wguk@r{8zyb;gx1p3K~cowJ>=fDKY|+QLS*z4?PI*&M8`4DVy-EhAPx;gTG)p9 z*Dwo;SM?EML<9Z}@bijS^)Wvb@E?I6RlKT?D&v0+K2c-+BI<@u>|5Ytz)yj#z-1uL zkJ#Hl)EIMt*aKr(U^8$Oh+1M7fR6yr0v`u<10MxOf!H?(kNenv6j%qj&By*0AYOvO zCLjBY$PxQ%jO)Xm8yf)fy2pWNWQ^;A=^*zH*kACmVP4^=!i2)8LIB%0tO2nvo?v_! zr4*FRh;t({uVhB77a3JDBl3wPl+5@LWX_A@F(U8CH|&Ikf^m{%OfHhg&45=n9{`yj zWgCp^m@Frh%x0dylD`I4%FnTk*unYQ$1)lmoR4ooZbpz>9311El7n~jJtg}r(GA?N zeej*!R&wxN6d`j?!6@LSQf@-LO8F9mN_nBmK3>K124894TE#zG#lK!9=c?>UJlM`F z@Iw=9p2Bv8+W&OZ%s?-NZrgeee`N<++0vA{Q`2Z%&KOB449jr$M!0G?LR`cFFn(#w zA#uQ-FC6JkX9+)px;>tmwGQw% zh%seaTCT{tw&)p$W!f}sk(Oy&ri7ajra6-qUjIn^Kd056r{(o}_%fNS (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.000000e+00> : tensor + %0 = catalyst.launch_kernel @module_f::@f(%cst) : (tensor) -> tensor + %1 = catalyst.launch_kernel @module_f_0::@f_1(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + module @module_f { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + transform.yield + } + } + func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<1> : tensor + %0 = quantum.alloc( 1) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit + %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %extracted_5 = tensor.extract %c[] : tensor + %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + module @module_f_0 { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @f_1(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<1> : tensor + %0 = quantum.alloc( 1) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit + %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %extracted_5 = tensor.extract %c[] : tensor + %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/1_EnforceRuntimeInvariantsPass.mlir b/test_cancel_inverses_keep_original_workflow2_2/1_EnforceRuntimeInvariantsPass.mlir new file mode 100644 index 0000000000..8fdb8e12bc --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow2_2/1_EnforceRuntimeInvariantsPass.mlir @@ -0,0 +1,48 @@ +module @test_cancel_inverses_keep_original_workflow2 { + func.func public @jit_test_cancel_inverses_keep_original_workflow2() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = stablehlo.constant dense<1.000000e+00> : tensor + %0 = call @f_0(%cst) : (tensor) -> tensor + %1 = call @f_1_0(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/2_HLOLoweringPass.mlir b/test_cancel_inverses_keep_original_workflow2_2/2_HLOLoweringPass.mlir new file mode 100644 index 0000000000..316c298aa8 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow2_2/2_HLOLoweringPass.mlir @@ -0,0 +1,48 @@ +module @test_cancel_inverses_keep_original_workflow2 { + func.func public @jit_test_cancel_inverses_keep_original_workflow2() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.000000e+00> : tensor + %0 = call @f_0(%cst) : (tensor) -> tensor + %1 = call @f_1_0(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/3_QuantumCompilationPass.mlir b/test_cancel_inverses_keep_original_workflow2_2/3_QuantumCompilationPass.mlir new file mode 100644 index 0000000000..316c298aa8 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow2_2/3_QuantumCompilationPass.mlir @@ -0,0 +1,48 @@ +module @test_cancel_inverses_keep_original_workflow2 { + func.func public @jit_test_cancel_inverses_keep_original_workflow2() -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %cst = arith.constant dense<1.000000e+00> : tensor + %0 = call @f_0(%cst) : (tensor) -> tensor + %1 = call @f_1_0(%cst) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/4_BufferizationPass.mlir b/test_cancel_inverses_keep_original_workflow2_2/4_BufferizationPass.mlir new file mode 100644 index 0000000000..35ac832e41 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow2_2/4_BufferizationPass.mlir @@ -0,0 +1,74 @@ +module @test_cancel_inverses_keep_original_workflow2 { + memref.global "private" constant @__constant_xf64 : memref = dense<1.000000e+00> {alignment = 64 : i64} + func.func public @jit_test_cancel_inverses_keep_original_workflow2() -> (memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(3735928559 : index) : i64 + %1 = memref.get_global @__constant_xf64 : memref + %2 = call @f_0(%1) : (memref) -> memref + %3 = call @f_1_0(%1) : (memref) -> memref + %4 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> + %5 = llvm.extractvalue %4[0] : !llvm.struct<(ptr, ptr, i64)> + %6 = llvm.ptrtoint %5 : !llvm.ptr to i64 + %7 = llvm.icmp "eq" %0, %6 : i64 + %8 = scf.if %7 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %2, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %2 : memref + } + %9 = builtin.unrealized_conversion_cast %3 : memref to !llvm.struct<(ptr, ptr, i64)> + %10 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> + %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 + %12 = llvm.icmp "eq" %0, %11 : i64 + %13 = scf.if %12 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %3, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %3 : memref + } + return %8, %13 : memref, memref + } + func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %4 = quantum.expval %3 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %4, %alloc[] : memref + %5 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %5 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func public @f_1_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %4 = quantum.expval %3 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %4, %alloc[] : memref + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %5 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/5_MLIRToLLVMDialect.mlir b/test_cancel_inverses_keep_original_workflow2_2/5_MLIRToLLVMDialect.mlir new file mode 100644 index 0000000000..5ea3d0d971 --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow2_2/5_MLIRToLLVMDialect.mlir @@ -0,0 +1,185 @@ +module @test_cancel_inverses_keep_original_workflow2 { + llvm.func @__catalyst__rt__finalize() + llvm.func @__catalyst__rt__initialize(!llvm.ptr) + llvm.func @__catalyst__rt__device_release() + llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) + llvm.func @__catalyst__qis__Expval(i64) -> f64 + llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 + llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr + llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr + llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} + llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) + llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr + llvm.mlir.global private constant @__constant_xf64(1.000000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 + llvm.func @jit_test_cancel_inverses_keep_original_workflow2() -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %1 = llvm.mlir.constant(0 : index) : i64 + %2 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %3 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr + %4 = llvm.mlir.constant(3735928559 : index) : i64 + %5 = llvm.mlir.constant(1 : index) : i64 + %6 = llvm.mlir.zero : !llvm.ptr + %7 = llvm.inttoptr %4 : i64 to !llvm.ptr + %8 = llvm.call @f_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %9 = llvm.call @f_1_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %10 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> + %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 + %12 = llvm.icmp "eq" %4, %11 : i64 + llvm.cond_br %12, ^bb1, ^bb2 + ^bb1: // pred: ^bb0 + %13 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %14 = llvm.ptrtoint %13 : !llvm.ptr to i64 + %15 = llvm.call @_mlir_memref_to_llvm_alloc(%14) : (i64) -> !llvm.ptr + %16 = llvm.insertvalue %15, %2[0] : !llvm.struct<(ptr, ptr, i64)> + %17 = llvm.insertvalue %15, %16[1] : !llvm.struct<(ptr, ptr, i64)> + %18 = llvm.insertvalue %1, %17[2] : !llvm.struct<(ptr, ptr, i64)> + %19 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %20 = llvm.ptrtoint %19 : !llvm.ptr to i64 + %21 = llvm.mul %20, %5 : i64 + %22 = llvm.extractvalue %8[1] : !llvm.struct<(ptr, ptr, i64)> + %23 = llvm.extractvalue %8[2] : !llvm.struct<(ptr, ptr, i64)> + %24 = llvm.getelementptr inbounds %22[%23] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%15, %24, %21) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb3(%18 : !llvm.struct<(ptr, ptr, i64)>) + ^bb2: // pred: ^bb0 + llvm.br ^bb3(%8 : !llvm.struct<(ptr, ptr, i64)>) + ^bb3(%25: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 + llvm.br ^bb4 + ^bb4: // pred: ^bb3 + %26 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> + %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 + %28 = llvm.icmp "eq" %4, %27 : i64 + llvm.cond_br %28, ^bb5, ^bb6 + ^bb5: // pred: ^bb4 + %29 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %30 = llvm.ptrtoint %29 : !llvm.ptr to i64 + %31 = llvm.call @_mlir_memref_to_llvm_alloc(%30) : (i64) -> !llvm.ptr + %32 = llvm.insertvalue %31, %2[0] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %1, %33[2] : !llvm.struct<(ptr, ptr, i64)> + %35 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %36 = llvm.ptrtoint %35 : !llvm.ptr to i64 + %37 = llvm.mul %36, %5 : i64 + %38 = llvm.extractvalue %9[1] : !llvm.struct<(ptr, ptr, i64)> + %39 = llvm.extractvalue %9[2] : !llvm.struct<(ptr, ptr, i64)> + %40 = llvm.getelementptr inbounds %38[%39] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%31, %40, %37) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb7(%34 : !llvm.struct<(ptr, ptr, i64)>) + ^bb6: // pred: ^bb4 + llvm.br ^bb7(%9 : !llvm.struct<(ptr, ptr, i64)>) + ^bb7(%41: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 + llvm.br ^bb8 + ^bb8: // pred: ^bb7 + %42 = llvm.insertvalue %25, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %43 = llvm.insertvalue %41, %42[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.return %43 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + } + llvm.func @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow2(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { + llvm.call @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow2(%arg0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow2(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.call @jit_test_cancel_inverses_keep_original_workflow2() : () -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.store %0, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr + llvm.return + } + llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(3 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(1 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () + llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 + %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 + %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 + %23 = llvm.add %22, %1 : i64 + %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr + %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 + %26 = llvm.sub %1, %2 : i64 + %27 = llvm.add %25, %26 : i64 + %28 = llvm.urem %27, %1 : i64 + %29 = llvm.sub %27, %28 : i64 + %30 = llvm.inttoptr %29 : i64 to !llvm.ptr + %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %20, %30 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func internal @f_1_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(3 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(1 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 + %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 + %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 + %23 = llvm.add %22, %1 : i64 + %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr + %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 + %26 = llvm.sub %1, %2 : i64 + %27 = llvm.add %25, %26 : i64 + %28 = llvm.urem %27, %1 : i64 + %29 = llvm.sub %27, %28 : i64 + %30 = llvm.inttoptr %29 : i64 to !llvm.ptr + %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %20, %30 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @setup() { + %0 = llvm.mlir.zero : !llvm.ptr + llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @teardown() { + llvm.call @__catalyst__rt__finalize() : () -> () + llvm.return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/6_llvm_ir.ll b/test_cancel_inverses_keep_original_workflow2_2/6_llvm_ir.ll new file mode 100644 index 0000000000..4aace33fee --- /dev/null +++ b/test_cancel_inverses_keep_original_workflow2_2/6_llvm_ir.ll @@ -0,0 +1,167 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" + +@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" +@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" +@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" +@__constant_xf64 = private constant double 1.000000e+00, align 64 + +declare void @__catalyst__rt__finalize() + +declare void @__catalyst__rt__initialize(ptr) + +declare void @__catalyst__rt__device_release() + +declare void @__catalyst__rt__qubit_release_array(ptr) + +declare double @__catalyst__qis__Expval(i64) + +declare i64 @__catalyst__qis__NamedObs(i64, ptr) + +declare void @__catalyst__qis__Hadamard(ptr, ptr) + +declare void @__catalyst__qis__RX(double, ptr, ptr) + +declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) + +declare ptr @__catalyst__rt__qubit_allocate_array(i64) + +declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) + +declare ptr @_mlir_memref_to_llvm_alloc(i64) + +define { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_cancel_inverses_keep_original_workflow2() { + %1 = call { ptr, ptr, i64 } @f_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) + %2 = call { ptr, ptr, i64 } @f_1_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) + %3 = extractvalue { ptr, ptr, i64 } %1, 0 + %4 = ptrtoint ptr %3 to i64 + %5 = icmp eq i64 3735928559, %4 + br i1 %5, label %6, label %14 + +6: ; preds = %0 + %7 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %8 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 + %9 = insertvalue { ptr, ptr, i64 } %8, ptr %7, 1 + %10 = insertvalue { ptr, ptr, i64 } %9, i64 0, 2 + %11 = extractvalue { ptr, ptr, i64 } %1, 1 + %12 = extractvalue { ptr, ptr, i64 } %1, 2 + %13 = getelementptr inbounds double, ptr %11, i64 %12 + call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %13, i64 8, i1 false) + br label %15 + +14: ; preds = %0 + br label %15 + +15: ; preds = %6, %14 + %16 = phi { ptr, ptr, i64 } [ %1, %14 ], [ %10, %6 ] + br label %17 + +17: ; preds = %15 + %18 = extractvalue { ptr, ptr, i64 } %2, 0 + %19 = ptrtoint ptr %18 to i64 + %20 = icmp eq i64 3735928559, %19 + br i1 %20, label %21, label %29 + +21: ; preds = %17 + %22 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %23 = insertvalue { ptr, ptr, i64 } poison, ptr %22, 0 + %24 = insertvalue { ptr, ptr, i64 } %23, ptr %22, 1 + %25 = insertvalue { ptr, ptr, i64 } %24, i64 0, 2 + %26 = extractvalue { ptr, ptr, i64 } %2, 1 + %27 = extractvalue { ptr, ptr, i64 } %2, 2 + %28 = getelementptr inbounds double, ptr %26, i64 %27 + call void @llvm.memcpy.p0.p0.i64(ptr %22, ptr %28, i64 8, i1 false) + br label %30 + +29: ; preds = %17 + br label %30 + +30: ; preds = %21, %29 + %31 = phi { ptr, ptr, i64 } [ %2, %29 ], [ %25, %21 ] + br label %32 + +32: ; preds = %30 + %33 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %16, 0 + %34 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %33, { ptr, ptr, i64 } %31, 1 + ret { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %34 +} + +define void @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow2(ptr %0, ptr %1) { + call void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow2(ptr %0) + ret void +} + +define void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow2(ptr %0) { + %2 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_cancel_inverses_keep_original_workflow2() + store { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %2, ptr %0, align 8 + ret void +} + +define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + call void @__catalyst__qis__Hadamard(ptr %6, ptr null) + call void @__catalyst__qis__Hadamard(ptr %6, ptr null) + %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) + %9 = call double @__catalyst__qis__Expval(i64 %8) + %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %11 = ptrtoint ptr %10 to i64 + %12 = add i64 %11, 63 + %13 = urem i64 %12, 64 + %14 = sub i64 %12, %13 + %15 = inttoptr i64 %14 to ptr + %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 + %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 + %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 + store double %9, ptr %15, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %18 +} + +define internal { ptr, ptr, i64 } @f_1_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) + %9 = call double @__catalyst__qis__Expval(i64 %8) + %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %11 = ptrtoint ptr %10 to i64 + %12 = add i64 %11, 63 + %13 = urem i64 %12, 64 + %14 = sub i64 %12, %13 + %15 = inttoptr i64 %14 to ptr + %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 + %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 + %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 + store double %9, ptr %15, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %18 +} + +define void @setup() { + call void @__catalyst__rt__initialize(ptr null) + ret void +} + +define void @teardown() { + call void @__catalyst__rt__finalize() + ret void +} + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 + +attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_cancel_inverses_keep_original_workflow2_2/test_cancel_inverses_keep_original_workflow2.o b/test_cancel_inverses_keep_original_workflow2_2/test_cancel_inverses_keep_original_workflow2.o new file mode 100644 index 0000000000000000000000000000000000000000..e6c8f2ad10b13c813b2c5298a2d876df1b76185a GIT binary patch literal 3960 zcmc&%OKcNI7@my-I6R!tK!JjYs~!>+j7fq@Rj_ai6e>j!(NyA4b+WO?$&&TjtT!*x zN|xZjp@*bG;zFw&6HYz!PzfYlsfXO4Rf|wXrA-Kx=|iGb57|m?`u)4JiS6Kua-bv4 ze*6F5|D0X#jBo$-+us`*Qy2za>M?_LxP&n=c3@t1Syx6DQOMaKV|z(e&+-KR;5?Braw`EjuZ&laae}h;;u^+e zseXtGqq^$@xIbbp*R&A7aj2Cv)ZxGN+bJF~F|d zhvH802yBnS_5^c^h&PRREeiWZsbf7sC4a^a1Yf0?KOcl`XWV&2e#kQyXt+L)85}#e z*rve06>;_;Uz9nhXNwK{IoQu5M>&Tz+hVtZ+XH-;P(o19vwlB3BFaz*g2fq!>c^HU03+v*}gALH{giT8v zwZ)y%_&YOL_sK$l-z|;bnxQo*jej*w^3p|y=b_Blh(Y=y{MT${PW@))1U50Ju7Nqq z8gL3joHr4Nxp9_`D)6hHq1^DBz??*F6E6et+DyC!e1Nrnfc04jw7AcqjjcQrw>I?a z=Omdi)Qdit5-*Y7MjxKO@_r8bfwEYxZ6hlM8&=}mjq#HEo?xAdw5BCC8GLx*lOmoO zdU4~septgftkpd7m&T9Hps(lF-}C5$o;SVo)T{r@tKR`|Pd&z4(}{GV^^Ne`s-6>j z!>z_pn)eNvhGsyyABsU?8bap=K3UM5${6CKvgln}|9}PK{&%(Xkgi%8vy8-T^u3%g zbJ4_rspTxqP@~;urazicEma@OSzH*yQC;hcX2-07jM2HTy(5~_ED^yMcTnvYxoB1x z#+a@eg6n=Ja#$Al`Jq0|;(ow=$uY2%B|L@n_=ss|=^`N4su%82b{4qe0gf9>zWfQr^oz%9{jI z-X0+3?FLfbI1oKV4oIZ)4%N{Fq&n(>RL3ITC#s_eq&gNnjM+e{m!R1|KVUxOPfnUShArxWuqT z0Qs%8feno9Cd9cWRFE>^CdgA#CPY12bNG^dSlZt}Ad+cuX;5f49*U)5lRsub%0G~dd;h$6 zie&iu=e?_t8xh3+j=1jyCVyiumRH zxhngMRrb*;9-DoIe{&Tt-zQjk;{!l>zAIJsj6d7X#BpHvHy3VNT<#C5u4kYZTs2K~ z4F5WwXk`jrsJWU(NinP?1lJ7Bs*G@6%W-}R8)WiyUyku7?1?-ltf4H!pB>dqW=4!B z_#Yq54y$@4K@Fs^YwFqsv6`Vmv>KeORd!VA>y~>`O{!@WQ%O-mcZqnv!0xPzv@k55 zwM^blmT6rxd0M1Rk>XZ{>-un-yGzUX|Fh9oJV>{%GiRAjTKX5LqW00$YX_KarL&!= zfBDtOj-^yQ%5yk6SOVveglZ&k$kB{poK{4R4+@dx8B^=0#pfd#b1 ULA7+a6}7w9{fwu$dua#!1AxJvf&c&j literal 0 HcmV?d00001 diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/0_test_cancel_inverses_lowering_transform_applied_workflow.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/0_test_cancel_inverses_lowering_transform_applied_workflow.mlir new file mode 100644 index 0000000000..e70fb2caad --- /dev/null +++ b/test_cancel_inverses_lowering_transform_applied_workflow_2/0_test_cancel_inverses_lowering_transform_applied_workflow.mlir @@ -0,0 +1,102 @@ +module @test_cancel_inverses_lowering_transform_applied_workflow { + func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: tensor) -> (tensor, tensor, tensor) attributes {llvm.emit_c_interface} { + %0 = catalyst.launch_kernel @module_f::@f(%arg0) : (tensor) -> tensor + %1 = catalyst.launch_kernel @module_g::@g(%arg0) : (tensor) -> tensor + %2 = catalyst.launch_kernel @module_h::@h(%arg0) : (tensor) -> tensor + return %0, %1, %2 : tensor, tensor, tensor + } + module @module_f { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<1> : tensor + %0 = quantum.alloc( 1) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit + %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %extracted_5 = tensor.extract %c[] : tensor + %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + module @module_g { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + transform.yield + } + } + func.func public @g(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<1> : tensor + %0 = quantum.alloc( 1) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit + %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %extracted_5 = tensor.extract %c[] : tensor + %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + module @module_h { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @h(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<1> : tensor + %0 = quantum.alloc( 1) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits_3 = quantum.custom "RX"(%extracted_2) %out_qubits : !quantum.bit + %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit + %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %extracted_5 = tensor.extract %c[] : tensor + %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/1_EnforceRuntimeInvariantsPass.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/1_EnforceRuntimeInvariantsPass.mlir new file mode 100644 index 0000000000..dd3ab9f8dd --- /dev/null +++ b/test_cancel_inverses_lowering_transform_applied_workflow_2/1_EnforceRuntimeInvariantsPass.mlir @@ -0,0 +1,65 @@ +module @test_cancel_inverses_lowering_transform_applied_workflow { + func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: tensor) -> (tensor, tensor, tensor) attributes {llvm.emit_c_interface} { + %0 = call @f_0(%arg0) : (tensor) -> tensor + %1 = call @g_0(%arg0) : (tensor) -> tensor + %2 = call @h_0(%arg0) : (tensor) -> tensor + return %0, %1, %2 : tensor, tensor, tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits_0 = quantum.custom "RX"(%extracted) %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/2_HLOLoweringPass.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/2_HLOLoweringPass.mlir new file mode 100644 index 0000000000..dd3ab9f8dd --- /dev/null +++ b/test_cancel_inverses_lowering_transform_applied_workflow_2/2_HLOLoweringPass.mlir @@ -0,0 +1,65 @@ +module @test_cancel_inverses_lowering_transform_applied_workflow { + func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: tensor) -> (tensor, tensor, tensor) attributes {llvm.emit_c_interface} { + %0 = call @f_0(%arg0) : (tensor) -> tensor + %1 = call @g_0(%arg0) : (tensor) -> tensor + %2 = call @h_0(%arg0) : (tensor) -> tensor + return %0, %1, %2 : tensor, tensor, tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits_0 = quantum.custom "RX"(%extracted) %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/3_QuantumCompilationPass.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/3_QuantumCompilationPass.mlir new file mode 100644 index 0000000000..dd3ab9f8dd --- /dev/null +++ b/test_cancel_inverses_lowering_transform_applied_workflow_2/3_QuantumCompilationPass.mlir @@ -0,0 +1,65 @@ +module @test_cancel_inverses_lowering_transform_applied_workflow { + func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: tensor) -> (tensor, tensor, tensor) attributes {llvm.emit_c_interface} { + %0 = call @f_0(%arg0) : (tensor) -> tensor + %1 = call @g_0(%arg0) : (tensor) -> tensor + %2 = call @h_0(%arg0) : (tensor) -> tensor + return %0, %1, %2 : tensor, tensor, tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits_0 = quantum.custom "RX"(%extracted) %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %3 = quantum.expval %2 : f64 + %from_elements = tensor.from_elements %3 : tensor + %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %4 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/4_BufferizationPass.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/4_BufferizationPass.mlir new file mode 100644 index 0000000000..c26306caaa --- /dev/null +++ b/test_cancel_inverses_lowering_transform_applied_workflow_2/4_BufferizationPass.mlir @@ -0,0 +1,102 @@ +module @test_cancel_inverses_lowering_transform_applied_workflow { + func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: memref) -> (memref, memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(3735928559 : index) : i64 + %1 = call @f_0(%arg0) : (memref) -> memref + %2 = call @g_0(%arg0) : (memref) -> memref + %3 = call @h_0(%arg0) : (memref) -> memref + %4 = builtin.unrealized_conversion_cast %1 : memref to !llvm.struct<(ptr, ptr, i64)> + %5 = llvm.extractvalue %4[0] : !llvm.struct<(ptr, ptr, i64)> + %6 = llvm.ptrtoint %5 : !llvm.ptr to i64 + %7 = llvm.icmp "eq" %0, %6 : i64 + %8 = scf.if %7 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %1, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %1 : memref + } + %9 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> + %10 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> + %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 + %12 = llvm.icmp "eq" %0, %11 : i64 + %13 = scf.if %12 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %2, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %2 : memref + } + %14 = builtin.unrealized_conversion_cast %3 : memref to !llvm.struct<(ptr, ptr, i64)> + %15 = llvm.extractvalue %14[0] : !llvm.struct<(ptr, ptr, i64)> + %16 = llvm.ptrtoint %15 : !llvm.ptr to i64 + %17 = llvm.icmp "eq" %0, %16 : i64 + %18 = scf.if %17 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %3, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %3 : memref + } + return %8, %13, %18 : memref, memref, memref + } + func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs + %4 = quantum.expval %3 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %4, %alloc[] : memref + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + quantum.dealloc %5 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func public @g_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %4 = quantum.expval %3 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %4, %alloc[] : memref + %5 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %5 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func public @h_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 1) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits_0 = quantum.custom "RX"(%2) %out_qubits : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs + %4 = quantum.expval %3 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %4, %alloc[] : memref + %5 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %5 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/5_MLIRToLLVMDialect.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/5_MLIRToLLVMDialect.mlir new file mode 100644 index 0000000000..647e8a6261 --- /dev/null +++ b/test_cancel_inverses_lowering_transform_applied_workflow_2/5_MLIRToLLVMDialect.mlir @@ -0,0 +1,258 @@ +module @test_cancel_inverses_lowering_transform_applied_workflow { + llvm.func @__catalyst__rt__finalize() + llvm.func @__catalyst__rt__initialize(!llvm.ptr) + llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__device_release() + llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) + llvm.func @__catalyst__qis__Expval(i64) -> f64 + llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 + llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr + llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr + llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} + llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) + llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr + llvm.func @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %1 = llvm.mlir.constant(0 : index) : i64 + %2 = llvm.mlir.zero : !llvm.ptr + %3 = llvm.mlir.constant(1 : index) : i64 + %4 = llvm.mlir.constant(3735928559 : index) : i64 + %5 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %6 = llvm.call @f_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %7 = llvm.call @g_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %8 = llvm.call @h_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %9 = llvm.extractvalue %6[0] : !llvm.struct<(ptr, ptr, i64)> + %10 = llvm.ptrtoint %9 : !llvm.ptr to i64 + %11 = llvm.icmp "eq" %4, %10 : i64 + llvm.cond_br %11, ^bb1, ^bb2 + ^bb1: // pred: ^bb0 + %12 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %13 = llvm.ptrtoint %12 : !llvm.ptr to i64 + %14 = llvm.call @_mlir_memref_to_llvm_alloc(%13) : (i64) -> !llvm.ptr + %15 = llvm.insertvalue %14, %5[0] : !llvm.struct<(ptr, ptr, i64)> + %16 = llvm.insertvalue %14, %15[1] : !llvm.struct<(ptr, ptr, i64)> + %17 = llvm.insertvalue %1, %16[2] : !llvm.struct<(ptr, ptr, i64)> + %18 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %19 = llvm.ptrtoint %18 : !llvm.ptr to i64 + %20 = llvm.mul %19, %3 : i64 + %21 = llvm.extractvalue %6[1] : !llvm.struct<(ptr, ptr, i64)> + %22 = llvm.extractvalue %6[2] : !llvm.struct<(ptr, ptr, i64)> + %23 = llvm.getelementptr inbounds %21[%22] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%14, %23, %20) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb3(%17 : !llvm.struct<(ptr, ptr, i64)>) + ^bb2: // pred: ^bb0 + llvm.br ^bb3(%6 : !llvm.struct<(ptr, ptr, i64)>) + ^bb3(%24: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 + llvm.br ^bb4 + ^bb4: // pred: ^bb3 + %25 = llvm.extractvalue %7[0] : !llvm.struct<(ptr, ptr, i64)> + %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 + %27 = llvm.icmp "eq" %4, %26 : i64 + llvm.cond_br %27, ^bb5, ^bb6 + ^bb5: // pred: ^bb4 + %28 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %29 = llvm.ptrtoint %28 : !llvm.ptr to i64 + %30 = llvm.call @_mlir_memref_to_llvm_alloc(%29) : (i64) -> !llvm.ptr + %31 = llvm.insertvalue %30, %5[0] : !llvm.struct<(ptr, ptr, i64)> + %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %1, %32[2] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %35 = llvm.ptrtoint %34 : !llvm.ptr to i64 + %36 = llvm.mul %35, %3 : i64 + %37 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64)> + %38 = llvm.extractvalue %7[2] : !llvm.struct<(ptr, ptr, i64)> + %39 = llvm.getelementptr inbounds %37[%38] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%30, %39, %36) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb7(%33 : !llvm.struct<(ptr, ptr, i64)>) + ^bb6: // pred: ^bb4 + llvm.br ^bb7(%7 : !llvm.struct<(ptr, ptr, i64)>) + ^bb7(%40: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 + llvm.br ^bb8 + ^bb8: // pred: ^bb7 + %41 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> + %42 = llvm.ptrtoint %41 : !llvm.ptr to i64 + %43 = llvm.icmp "eq" %4, %42 : i64 + llvm.cond_br %43, ^bb9, ^bb10 + ^bb9: // pred: ^bb8 + %44 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %45 = llvm.ptrtoint %44 : !llvm.ptr to i64 + %46 = llvm.call @_mlir_memref_to_llvm_alloc(%45) : (i64) -> !llvm.ptr + %47 = llvm.insertvalue %46, %5[0] : !llvm.struct<(ptr, ptr, i64)> + %48 = llvm.insertvalue %46, %47[1] : !llvm.struct<(ptr, ptr, i64)> + %49 = llvm.insertvalue %1, %48[2] : !llvm.struct<(ptr, ptr, i64)> + %50 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %51 = llvm.ptrtoint %50 : !llvm.ptr to i64 + %52 = llvm.mul %51, %3 : i64 + %53 = llvm.extractvalue %8[1] : !llvm.struct<(ptr, ptr, i64)> + %54 = llvm.extractvalue %8[2] : !llvm.struct<(ptr, ptr, i64)> + %55 = llvm.getelementptr inbounds %53[%54] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%46, %55, %52) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb11(%49 : !llvm.struct<(ptr, ptr, i64)>) + ^bb10: // pred: ^bb8 + llvm.br ^bb11(%8 : !llvm.struct<(ptr, ptr, i64)>) + ^bb11(%56: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb9, ^bb10 + llvm.br ^bb12 + ^bb12: // pred: ^bb11 + %57 = llvm.insertvalue %24, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %58 = llvm.insertvalue %40, %57[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %59 = llvm.insertvalue %56, %58[2] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.return %59 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + } + llvm.func @_catalyst_pyface_jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { + %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr)> + %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr)> + llvm.call @_catalyst_ciface_jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0, %1) : (!llvm.ptr, !llvm.ptr) -> () + llvm.return + } + llvm.func @_catalyst_ciface_jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr, i64)> + %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr, i64)> + %2 = llvm.extractvalue %0[1] : !llvm.struct<(ptr, ptr, i64)> + %3 = llvm.extractvalue %0[2] : !llvm.struct<(ptr, ptr, i64)> + %4 = llvm.call @jit_test_cancel_inverses_lowering_transform_applied_workflow(%1, %2, %3) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.store %4, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr + llvm.return + } + llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(3 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(1 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 + %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 + %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 + %23 = llvm.add %22, %1 : i64 + %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr + %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 + %26 = llvm.sub %1, %2 : i64 + %27 = llvm.add %25, %26 : i64 + %28 = llvm.urem %27, %1 : i64 + %29 = llvm.sub %27, %28 : i64 + %30 = llvm.inttoptr %29 : i64 to !llvm.ptr + %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %20, %30 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func internal @g_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(3 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(1 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () + llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 + %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 + %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 + %23 = llvm.add %22, %1 : i64 + %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr + %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 + %26 = llvm.sub %1, %2 : i64 + %27 = llvm.add %25, %26 : i64 + %28 = llvm.urem %27, %1 : i64 + %29 = llvm.sub %27, %28 : i64 + %30 = llvm.inttoptr %29 : i64 to !llvm.ptr + %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %20, %30 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func internal @h_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(3 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(1 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 + %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 + %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 + %23 = llvm.add %22, %1 : i64 + %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr + %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 + %26 = llvm.sub %1, %2 : i64 + %27 = llvm.add %25, %26 : i64 + %28 = llvm.urem %27, %1 : i64 + %29 = llvm.sub %27, %28 : i64 + %30 = llvm.inttoptr %29 : i64 to !llvm.ptr + %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %20, %30 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @setup() { + %0 = llvm.mlir.zero : !llvm.ptr + llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @teardown() { + llvm.call @__catalyst__rt__finalize() : () -> () + llvm.return + } +} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/6_llvm_ir.ll b/test_cancel_inverses_lowering_transform_applied_workflow_2/6_llvm_ir.ll new file mode 100644 index 0000000000..c9dcdeca50 --- /dev/null +++ b/test_cancel_inverses_lowering_transform_applied_workflow_2/6_llvm_ir.ll @@ -0,0 +1,224 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" + +@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" +@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" +@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" + +declare void @__catalyst__rt__finalize() + +declare void @__catalyst__rt__initialize(ptr) + +declare void @__catalyst__qis__Hadamard(ptr, ptr) + +declare void @__catalyst__rt__device_release() + +declare void @__catalyst__rt__qubit_release_array(ptr) + +declare double @__catalyst__qis__Expval(i64) + +declare i64 @__catalyst__qis__NamedObs(i64, ptr) + +declare void @__catalyst__qis__RX(double, ptr, ptr) + +declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) + +declare ptr @__catalyst__rt__qubit_allocate_array(i64) + +declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) + +declare ptr @_mlir_memref_to_llvm_alloc(i64) + +define { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %0, ptr %1, i64 %2) { + %4 = call { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) + %5 = call { ptr, ptr, i64 } @g_0(ptr %0, ptr %1, i64 %2) + %6 = call { ptr, ptr, i64 } @h_0(ptr %0, ptr %1, i64 %2) + %7 = extractvalue { ptr, ptr, i64 } %4, 0 + %8 = ptrtoint ptr %7 to i64 + %9 = icmp eq i64 3735928559, %8 + br i1 %9, label %10, label %18 + +10: ; preds = %3 + %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %12 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 + %13 = insertvalue { ptr, ptr, i64 } %12, ptr %11, 1 + %14 = insertvalue { ptr, ptr, i64 } %13, i64 0, 2 + %15 = extractvalue { ptr, ptr, i64 } %4, 1 + %16 = extractvalue { ptr, ptr, i64 } %4, 2 + %17 = getelementptr inbounds double, ptr %15, i64 %16 + call void @llvm.memcpy.p0.p0.i64(ptr %11, ptr %17, i64 8, i1 false) + br label %19 + +18: ; preds = %3 + br label %19 + +19: ; preds = %10, %18 + %20 = phi { ptr, ptr, i64 } [ %4, %18 ], [ %14, %10 ] + br label %21 + +21: ; preds = %19 + %22 = extractvalue { ptr, ptr, i64 } %5, 0 + %23 = ptrtoint ptr %22 to i64 + %24 = icmp eq i64 3735928559, %23 + br i1 %24, label %25, label %33 + +25: ; preds = %21 + %26 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %27 = insertvalue { ptr, ptr, i64 } poison, ptr %26, 0 + %28 = insertvalue { ptr, ptr, i64 } %27, ptr %26, 1 + %29 = insertvalue { ptr, ptr, i64 } %28, i64 0, 2 + %30 = extractvalue { ptr, ptr, i64 } %5, 1 + %31 = extractvalue { ptr, ptr, i64 } %5, 2 + %32 = getelementptr inbounds double, ptr %30, i64 %31 + call void @llvm.memcpy.p0.p0.i64(ptr %26, ptr %32, i64 8, i1 false) + br label %34 + +33: ; preds = %21 + br label %34 + +34: ; preds = %25, %33 + %35 = phi { ptr, ptr, i64 } [ %5, %33 ], [ %29, %25 ] + br label %36 + +36: ; preds = %34 + %37 = extractvalue { ptr, ptr, i64 } %6, 0 + %38 = ptrtoint ptr %37 to i64 + %39 = icmp eq i64 3735928559, %38 + br i1 %39, label %40, label %48 + +40: ; preds = %36 + %41 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %42 = insertvalue { ptr, ptr, i64 } poison, ptr %41, 0 + %43 = insertvalue { ptr, ptr, i64 } %42, ptr %41, 1 + %44 = insertvalue { ptr, ptr, i64 } %43, i64 0, 2 + %45 = extractvalue { ptr, ptr, i64 } %6, 1 + %46 = extractvalue { ptr, ptr, i64 } %6, 2 + %47 = getelementptr inbounds double, ptr %45, i64 %46 + call void @llvm.memcpy.p0.p0.i64(ptr %41, ptr %47, i64 8, i1 false) + br label %49 + +48: ; preds = %36 + br label %49 + +49: ; preds = %40, %48 + %50 = phi { ptr, ptr, i64 } [ %6, %48 ], [ %44, %40 ] + br label %51 + +51: ; preds = %49 + %52 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %20, 0 + %53 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } %52, { ptr, ptr, i64 } %35, 1 + %54 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } %53, { ptr, ptr, i64 } %50, 2 + ret { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } %54 +} + +define void @_catalyst_pyface_jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %0, ptr %1) { + %3 = load { ptr, ptr }, ptr %1, align 8 + %4 = extractvalue { ptr, ptr } %3, 0 + call void @_catalyst_ciface_jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %0, ptr %4) + ret void +} + +define void @_catalyst_ciface_jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %0, ptr %1) { + %3 = load { ptr, ptr, i64 }, ptr %1, align 8 + %4 = extractvalue { ptr, ptr, i64 } %3, 0 + %5 = extractvalue { ptr, ptr, i64 } %3, 1 + %6 = extractvalue { ptr, ptr, i64 } %3, 2 + %7 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %4, ptr %5, i64 %6) + store { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } %7, ptr %0, align 8 + ret void +} + +define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) + %9 = call double @__catalyst__qis__Expval(i64 %8) + %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %11 = ptrtoint ptr %10 to i64 + %12 = add i64 %11, 63 + %13 = urem i64 %12, 64 + %14 = sub i64 %12, %13 + %15 = inttoptr i64 %14 to ptr + %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 + %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 + %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 + store double %9, ptr %15, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %18 +} + +define internal { ptr, ptr, i64 } @g_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + call void @__catalyst__qis__Hadamard(ptr %6, ptr null) + call void @__catalyst__qis__Hadamard(ptr %6, ptr null) + %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) + %9 = call double @__catalyst__qis__Expval(i64 %8) + %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %11 = ptrtoint ptr %10 to i64 + %12 = add i64 %11, 63 + %13 = urem i64 %12, 64 + %14 = sub i64 %12, %13 + %15 = inttoptr i64 %14 to ptr + %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 + %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 + %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 + store double %9, ptr %15, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %18 +} + +define internal { ptr, ptr, i64 } @h_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + call void @__catalyst__qis__Hadamard(ptr %6, ptr null) + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + call void @__catalyst__qis__Hadamard(ptr %6, ptr null) + %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) + %9 = call double @__catalyst__qis__Expval(i64 %8) + %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %11 = ptrtoint ptr %10 to i64 + %12 = add i64 %11, 63 + %13 = urem i64 %12, 64 + %14 = sub i64 %12, %13 + %15 = inttoptr i64 %14 to ptr + %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 + %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 + %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 + store double %9, ptr %15, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %18 +} + +define void @setup() { + call void @__catalyst__rt__initialize(ptr null) + ret void +} + +define void @teardown() { + call void @__catalyst__rt__finalize() + ret void +} + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 + +attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/test_cancel_inverses_lowering_transform_applied_workflow.o b/test_cancel_inverses_lowering_transform_applied_workflow_2/test_cancel_inverses_lowering_transform_applied_workflow.o new file mode 100644 index 0000000000000000000000000000000000000000..a3c4fbadba8bff251326e562585e7c0ac11cff7a GIT binary patch literal 4640 zcmdT{U2GIp6u#Rnu%%_YND&aUMNCSBWm|ZFh^reZLZpET7%>_z!|t>@bar-~owk(q zrwKgt!3QuVkcfr{9@;)(;)97MVuFb;#-FG$Mw2O2vs((NF_CM!)bGsP+3s!uqcIw9 z_Rcrw=brQ3b7$t>{q*;%Hyar9F*Lf=q6cblX+cL@fj;b59dXWOB;cyn(ik*PUVwY* z6ptF`mU_f;?_GKS_5=H8W$$ieo_j~}DCB1g8QV&#S~f)BHO}K{BRdgOqBPgCMfvkY*$GMv1-KLUK zJ-L$KFck-_#fw+x#>*pK2>N=)l8%GCYy>VxcirzPnJ6jglZzNzN%xK517aA@y3nbi zgifcDz|4^1FSnUvwVzL?L!-sq;?YaJOpM2wu%BfjzlR9~dp+-GWA?K#kKVIh7Q|6a0^UGq~0CMG+xbzBqzCZQF$XD!46#;94)8C)e-d#gVJk?R!(j<*%b;J0 zz5up*jB7;S4E-MHnvrKgOiXQ!iK}a3;#z%7Tz@nserk=0pBrPMeFYP3itgPM(fey-Vl|67&s8z^;Rxwx zj`=<>=H`vkvt|34sHuwy-#qyEP>(h2Bs~MRANSx>0FO!JzXJYK;C~hTuYv1za3pS_ z7A6{3F%ewO#G)o98bVCeH!!g7 ze&wIzs}@rP!jkHeTOuQdjU5j24O9ukfe>z-7?Fx*auy`vnSrlJ|yigx}#_duV~ZK{;{i_ zW4|ah_HFFvBjn%P=7(ivc4#%*2= zSZDBT&0D@VYu@mm@yVkngMt!| zU-4uRj|m|0z@A7L{SHVxzHu@7B@jb8KXWlU0wf;ifW%`6NIWt?;-LeH$8$i++X1A! zTY!{zJ&^LQ0#e@PE=HSxlsDvJv;jzY11?6-;=RJTGi(8I9u1$v8d6?5{}P_TniJ|k z3<-At;Topr5iVid#rYQ`o|QNx@u0+*#1@GF8b3dP3y#?L5eD(gLr*dxj?O`Pj!7m& z{@{p|3Be;cEM-Cpk(4qa<`dj0WkQ_2gT$NS5n|rKDGGvtUZd{}$=>(oHz|AHmtUmp zeNT3ij2=SKsXap^ApeA-Q=`x%d;fcWl>VM?at8#uXXj#s85z%gAlU!xJE5|x?cPa@b1u~T;O6V*g?@@8a(bbe{SUh8y zyq!E#x@Pi}nljaHZl$@d_hT7o;TivLj!PAfnKQ4w2bgZ9GMk+1M(5h@T-z8=a$I`o J(v6F3e*ncAp$7l} literal 0 HcmV?d00001 diff --git a/test_pipeline_lowering_keep_original_workflow_3/0_test_pipeline_lowering_keep_original_workflow.mlir b/test_pipeline_lowering_keep_original_workflow_3/0_test_pipeline_lowering_keep_original_workflow.mlir new file mode 100644 index 0000000000..492a27222d --- /dev/null +++ b/test_pipeline_lowering_keep_original_workflow_3/0_test_pipeline_lowering_keep_original_workflow.mlir @@ -0,0 +1,83 @@ +module @test_pipeline_lowering_keep_original_workflow { + func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: tensor) -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %0 = catalyst.launch_kernel @module_f::@f(%arg0) : (tensor) -> tensor + %1 = catalyst.launch_kernel @module_f_0::@f_1(%arg0) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + module @module_f { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + transform.yield + } + } + func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<2> : tensor + %0 = quantum.alloc( 2) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %c_3 = stablehlo.constant dense<1> : tensor + %extracted_4 = tensor.extract %c_3[] : tensor + %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit + %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %extracted_7 = tensor.extract %c[] : tensor + %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit + %extracted_8 = tensor.extract %c_3[] : tensor + %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + module @module_f_0 { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @f_1(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<2> : tensor + %0 = quantum.alloc( 2) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %c_3 = stablehlo.constant dense<1> : tensor + %extracted_4 = tensor.extract %c_3[] : tensor + %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit + %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %extracted_7 = tensor.extract %c[] : tensor + %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit + %extracted_8 = tensor.extract %c_3[] : tensor + %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/1_EnforceRuntimeInvariantsPass.mlir b/test_pipeline_lowering_keep_original_workflow_3/1_EnforceRuntimeInvariantsPass.mlir new file mode 100644 index 0000000000..3f9a41aaf9 --- /dev/null +++ b/test_pipeline_lowering_keep_original_workflow_3/1_EnforceRuntimeInvariantsPass.mlir @@ -0,0 +1,51 @@ +module @test_pipeline_lowering_keep_original_workflow { + func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: tensor) -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %0 = call @f_0(%arg0) : (tensor) -> tensor + %1 = call @f_1_0(%arg0) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/2_HLOLoweringPass.mlir b/test_pipeline_lowering_keep_original_workflow_3/2_HLOLoweringPass.mlir new file mode 100644 index 0000000000..3f9a41aaf9 --- /dev/null +++ b/test_pipeline_lowering_keep_original_workflow_3/2_HLOLoweringPass.mlir @@ -0,0 +1,51 @@ +module @test_pipeline_lowering_keep_original_workflow { + func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: tensor) -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %0 = call @f_0(%arg0) : (tensor) -> tensor + %1 = call @f_1_0(%arg0) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/3_QuantumCompilationPass.mlir b/test_pipeline_lowering_keep_original_workflow_3/3_QuantumCompilationPass.mlir new file mode 100644 index 0000000000..3f9a41aaf9 --- /dev/null +++ b/test_pipeline_lowering_keep_original_workflow_3/3_QuantumCompilationPass.mlir @@ -0,0 +1,51 @@ +module @test_pipeline_lowering_keep_original_workflow { + func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: tensor) -> (tensor, tensor) attributes {llvm.emit_c_interface} { + %0 = call @f_0(%arg0) : (tensor) -> tensor + %1 = call @f_1_0(%arg0) : (tensor) -> tensor + return %0, %1 : tensor, tensor + } + func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/4_BufferizationPass.mlir b/test_pipeline_lowering_keep_original_workflow_3/4_BufferizationPass.mlir new file mode 100644 index 0000000000..338b47cbc6 --- /dev/null +++ b/test_pipeline_lowering_keep_original_workflow_3/4_BufferizationPass.mlir @@ -0,0 +1,76 @@ +module @test_pipeline_lowering_keep_original_workflow { + func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: memref) -> (memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(3735928559 : index) : i64 + %1 = call @f_0(%arg0) : (memref) -> memref + %2 = call @f_1_0(%arg0) : (memref) -> memref + %3 = builtin.unrealized_conversion_cast %1 : memref to !llvm.struct<(ptr, ptr, i64)> + %4 = llvm.extractvalue %3[0] : !llvm.struct<(ptr, ptr, i64)> + %5 = llvm.ptrtoint %4 : !llvm.ptr to i64 + %6 = llvm.icmp "eq" %0, %5 : i64 + %7 = scf.if %6 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %1, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %1 : memref + } + %8 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> + %9 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> + %10 = llvm.ptrtoint %9 : !llvm.ptr to i64 + %11 = llvm.icmp "eq" %0, %10 : i64 + %12 = scf.if %11 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %2, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %2 : memref + } + return %7, %12 : memref, memref + } + func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %out_qubits_0 = quantum.custom "Hadamard"() %3 : !quantum.bit + %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit + %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %5 = quantum.expval %4 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %5, %alloc[] : memref + %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %7 = quantum.insert %6[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit + quantum.dealloc %7 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func public @f_1_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %5 = quantum.expval %4 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %5, %alloc[] : memref + %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit + quantum.dealloc %7 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/5_MLIRToLLVMDialect.mlir b/test_pipeline_lowering_keep_original_workflow_3/5_MLIRToLLVMDialect.mlir new file mode 100644 index 0000000000..98d9fda263 --- /dev/null +++ b/test_pipeline_lowering_keep_original_workflow_3/5_MLIRToLLVMDialect.mlir @@ -0,0 +1,191 @@ +module @test_pipeline_lowering_keep_original_workflow { + llvm.func @__catalyst__rt__finalize() + llvm.func @__catalyst__rt__initialize(!llvm.ptr) + llvm.func @__catalyst__rt__device_release() + llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) + llvm.func @__catalyst__qis__Expval(i64) -> f64 + llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 + llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr + llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr + llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} + llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) + llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr + llvm.func @jit_test_pipeline_lowering_keep_original_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %1 = llvm.mlir.constant(0 : index) : i64 + %2 = llvm.mlir.zero : !llvm.ptr + %3 = llvm.mlir.constant(1 : index) : i64 + %4 = llvm.mlir.constant(3735928559 : index) : i64 + %5 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %6 = llvm.call @f_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %7 = llvm.call @f_1_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %8 = llvm.extractvalue %6[0] : !llvm.struct<(ptr, ptr, i64)> + %9 = llvm.ptrtoint %8 : !llvm.ptr to i64 + %10 = llvm.icmp "eq" %4, %9 : i64 + llvm.cond_br %10, ^bb1, ^bb2 + ^bb1: // pred: ^bb0 + %11 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %12 = llvm.ptrtoint %11 : !llvm.ptr to i64 + %13 = llvm.call @_mlir_memref_to_llvm_alloc(%12) : (i64) -> !llvm.ptr + %14 = llvm.insertvalue %13, %5[0] : !llvm.struct<(ptr, ptr, i64)> + %15 = llvm.insertvalue %13, %14[1] : !llvm.struct<(ptr, ptr, i64)> + %16 = llvm.insertvalue %1, %15[2] : !llvm.struct<(ptr, ptr, i64)> + %17 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %18 = llvm.ptrtoint %17 : !llvm.ptr to i64 + %19 = llvm.mul %18, %3 : i64 + %20 = llvm.extractvalue %6[1] : !llvm.struct<(ptr, ptr, i64)> + %21 = llvm.extractvalue %6[2] : !llvm.struct<(ptr, ptr, i64)> + %22 = llvm.getelementptr inbounds %20[%21] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%13, %22, %19) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb3(%16 : !llvm.struct<(ptr, ptr, i64)>) + ^bb2: // pred: ^bb0 + llvm.br ^bb3(%6 : !llvm.struct<(ptr, ptr, i64)>) + ^bb3(%23: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 + llvm.br ^bb4 + ^bb4: // pred: ^bb3 + %24 = llvm.extractvalue %7[0] : !llvm.struct<(ptr, ptr, i64)> + %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 + %26 = llvm.icmp "eq" %4, %25 : i64 + llvm.cond_br %26, ^bb5, ^bb6 + ^bb5: // pred: ^bb4 + %27 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %28 = llvm.ptrtoint %27 : !llvm.ptr to i64 + %29 = llvm.call @_mlir_memref_to_llvm_alloc(%28) : (i64) -> !llvm.ptr + %30 = llvm.insertvalue %29, %5[0] : !llvm.struct<(ptr, ptr, i64)> + %31 = llvm.insertvalue %29, %30[1] : !llvm.struct<(ptr, ptr, i64)> + %32 = llvm.insertvalue %1, %31[2] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %34 = llvm.ptrtoint %33 : !llvm.ptr to i64 + %35 = llvm.mul %34, %3 : i64 + %36 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64)> + %37 = llvm.extractvalue %7[2] : !llvm.struct<(ptr, ptr, i64)> + %38 = llvm.getelementptr inbounds %36[%37] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%29, %38, %35) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb7(%32 : !llvm.struct<(ptr, ptr, i64)>) + ^bb6: // pred: ^bb4 + llvm.br ^bb7(%7 : !llvm.struct<(ptr, ptr, i64)>) + ^bb7(%39: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 + llvm.br ^bb8 + ^bb8: // pred: ^bb7 + %40 = llvm.insertvalue %23, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + %41 = llvm.insertvalue %39, %40[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.return %41 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + } + llvm.func @_catalyst_pyface_jit_test_pipeline_lowering_keep_original_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { + %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr)> + %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr)> + llvm.call @_catalyst_ciface_jit_test_pipeline_lowering_keep_original_workflow(%arg0, %1) : (!llvm.ptr, !llvm.ptr) -> () + llvm.return + } + llvm.func @_catalyst_ciface_jit_test_pipeline_lowering_keep_original_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr, i64)> + %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr, i64)> + %2 = llvm.extractvalue %0[1] : !llvm.struct<(ptr, ptr, i64)> + %3 = llvm.extractvalue %0[2] : !llvm.struct<(ptr, ptr, i64)> + %4 = llvm.call @jit_test_pipeline_lowering_keep_original_workflow(%1, %2, %3) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> + llvm.store %4, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr + llvm.return + } + llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(1 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(2 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr + %20 = llvm.load %19 : !llvm.ptr -> !llvm.ptr + llvm.call @__catalyst__qis__Hadamard(%20, %4) : (!llvm.ptr, !llvm.ptr) -> () + llvm.call @__catalyst__qis__Hadamard(%20, %4) : (!llvm.ptr, !llvm.ptr) -> () + %21 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 + %22 = llvm.call @__catalyst__qis__Expval(%21) : (i64) -> f64 + %23 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %24 = llvm.ptrtoint %23 : !llvm.ptr to i64 + %25 = llvm.add %24, %1 : i64 + %26 = llvm.call @_mlir_memref_to_llvm_alloc(%25) : (i64) -> !llvm.ptr + %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 + %28 = llvm.sub %1, %2 : i64 + %29 = llvm.add %27, %28 : i64 + %30 = llvm.urem %29, %1 : i64 + %31 = llvm.sub %29, %30 : i64 + %32 = llvm.inttoptr %31 : i64 to !llvm.ptr + %33 = llvm.insertvalue %26, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %32, %33[1] : !llvm.struct<(ptr, ptr, i64)> + %35 = llvm.insertvalue %0, %34[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %22, %32 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %35 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func internal @f_1_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(1 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(2 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr + %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 + %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 + %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 + %24 = llvm.add %23, %1 : i64 + %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr + %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 + %27 = llvm.sub %1, %2 : i64 + %28 = llvm.add %26, %27 : i64 + %29 = llvm.urem %28, %1 : i64 + %30 = llvm.sub %28, %29 : i64 + %31 = llvm.inttoptr %30 : i64 to !llvm.ptr + %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %21, %31 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @setup() { + %0 = llvm.mlir.zero : !llvm.ptr + llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @teardown() { + llvm.call @__catalyst__rt__finalize() : () -> () + llvm.return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/6_llvm_ir.ll b/test_pipeline_lowering_keep_original_workflow_3/6_llvm_ir.ll new file mode 100644 index 0000000000..fa3cd5d3bf --- /dev/null +++ b/test_pipeline_lowering_keep_original_workflow_3/6_llvm_ir.ll @@ -0,0 +1,175 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" + +@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" +@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" +@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" + +declare void @__catalyst__rt__finalize() + +declare void @__catalyst__rt__initialize(ptr) + +declare void @__catalyst__rt__device_release() + +declare void @__catalyst__rt__qubit_release_array(ptr) + +declare double @__catalyst__qis__Expval(i64) + +declare i64 @__catalyst__qis__NamedObs(i64, ptr) + +declare void @__catalyst__qis__Hadamard(ptr, ptr) + +declare void @__catalyst__qis__RX(double, ptr, ptr) + +declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) + +declare ptr @__catalyst__rt__qubit_allocate_array(i64) + +declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) + +declare ptr @_mlir_memref_to_llvm_alloc(i64) + +define { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_pipeline_lowering_keep_original_workflow(ptr %0, ptr %1, i64 %2) { + %4 = call { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) + %5 = call { ptr, ptr, i64 } @f_1_0(ptr %0, ptr %1, i64 %2) + %6 = extractvalue { ptr, ptr, i64 } %4, 0 + %7 = ptrtoint ptr %6 to i64 + %8 = icmp eq i64 3735928559, %7 + br i1 %8, label %9, label %17 + +9: ; preds = %3 + %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %11 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 + %12 = insertvalue { ptr, ptr, i64 } %11, ptr %10, 1 + %13 = insertvalue { ptr, ptr, i64 } %12, i64 0, 2 + %14 = extractvalue { ptr, ptr, i64 } %4, 1 + %15 = extractvalue { ptr, ptr, i64 } %4, 2 + %16 = getelementptr inbounds double, ptr %14, i64 %15 + call void @llvm.memcpy.p0.p0.i64(ptr %10, ptr %16, i64 8, i1 false) + br label %18 + +17: ; preds = %3 + br label %18 + +18: ; preds = %9, %17 + %19 = phi { ptr, ptr, i64 } [ %4, %17 ], [ %13, %9 ] + br label %20 + +20: ; preds = %18 + %21 = extractvalue { ptr, ptr, i64 } %5, 0 + %22 = ptrtoint ptr %21 to i64 + %23 = icmp eq i64 3735928559, %22 + br i1 %23, label %24, label %32 + +24: ; preds = %20 + %25 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %26 = insertvalue { ptr, ptr, i64 } poison, ptr %25, 0 + %27 = insertvalue { ptr, ptr, i64 } %26, ptr %25, 1 + %28 = insertvalue { ptr, ptr, i64 } %27, i64 0, 2 + %29 = extractvalue { ptr, ptr, i64 } %5, 1 + %30 = extractvalue { ptr, ptr, i64 } %5, 2 + %31 = getelementptr inbounds double, ptr %29, i64 %30 + call void @llvm.memcpy.p0.p0.i64(ptr %25, ptr %31, i64 8, i1 false) + br label %33 + +32: ; preds = %20 + br label %33 + +33: ; preds = %24, %32 + %34 = phi { ptr, ptr, i64 } [ %5, %32 ], [ %28, %24 ] + br label %35 + +35: ; preds = %33 + %36 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %19, 0 + %37 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %36, { ptr, ptr, i64 } %34, 1 + ret { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %37 +} + +define void @_catalyst_pyface_jit_test_pipeline_lowering_keep_original_workflow(ptr %0, ptr %1) { + %3 = load { ptr, ptr }, ptr %1, align 8 + %4 = extractvalue { ptr, ptr } %3, 0 + call void @_catalyst_ciface_jit_test_pipeline_lowering_keep_original_workflow(ptr %0, ptr %4) + ret void +} + +define void @_catalyst_ciface_jit_test_pipeline_lowering_keep_original_workflow(ptr %0, ptr %1) { + %3 = load { ptr, ptr, i64 }, ptr %1, align 8 + %4 = extractvalue { ptr, ptr, i64 } %3, 0 + %5 = extractvalue { ptr, ptr, i64 } %3, 1 + %6 = extractvalue { ptr, ptr, i64 } %3, 2 + %7 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_pipeline_lowering_keep_original_workflow(ptr %4, ptr %5, i64 %6) + store { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %7, ptr %0, align 8 + ret void +} + +define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) + %9 = load ptr, ptr %8, align 8 + call void @__catalyst__qis__Hadamard(ptr %9, ptr null) + call void @__catalyst__qis__Hadamard(ptr %9, ptr null) + %10 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) + %11 = call double @__catalyst__qis__Expval(i64 %10) + %12 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %13 = ptrtoint ptr %12 to i64 + %14 = add i64 %13, 63 + %15 = urem i64 %14, 64 + %16 = sub i64 %14, %15 + %17 = inttoptr i64 %16 to ptr + %18 = insertvalue { ptr, ptr, i64 } poison, ptr %12, 0 + %19 = insertvalue { ptr, ptr, i64 } %18, ptr %17, 1 + %20 = insertvalue { ptr, ptr, i64 } %19, i64 0, 2 + store double %11, ptr %17, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %20 +} + +define internal { ptr, ptr, i64 } @f_1_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) + %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) + %10 = call double @__catalyst__qis__Expval(i64 %9) + %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %12 = ptrtoint ptr %11 to i64 + %13 = add i64 %12, 63 + %14 = urem i64 %13, 64 + %15 = sub i64 %13, %14 + %16 = inttoptr i64 %15 to ptr + %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 + %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 + %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 + store double %10, ptr %16, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %19 +} + +define void @setup() { + call void @__catalyst__rt__initialize(ptr null) + ret void +} + +define void @teardown() { + call void @__catalyst__rt__finalize() + ret void +} + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 + +attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_pipeline_lowering_keep_original_workflow_3/test_pipeline_lowering_keep_original_workflow.o b/test_pipeline_lowering_keep_original_workflow_3/test_pipeline_lowering_keep_original_workflow.o new file mode 100644 index 0000000000000000000000000000000000000000..48c67b01a773d9b0d391b24baff81102b9e4a9b3 GIT binary patch literal 3880 zcmc&%T}%{L6u!fPE}{!oEwvKC`T(h27o>@%N}LvKNhC^?Mjsk4!*YR<+1Yh=_;YPS z;|mWyXk*fc{=`R?m-5i04>c)Gnlx#e)HbQ@gH3i3leM*pF+MO&xAZ$Rcb44+n$(xx zaOb<{e&?Kf&bfE?4&VRz$KP8SQy3aOD$#=#cr>A-?M9z*Syx>1nBL?~wU7;(FK@<} zI{BlT#WD`ON$9# zE{$&n@lad#fX$;=8`y13k;!2SUIM3|FlXAX|Y&J6Uk&|kzF#T@FjGjjl31oQ3ajj-DfyJqG* zJdHI9F;uUO;T-t0{}RIv_^OAmJu(L9XQ96czl%kj8^aE8^_bs-z8Q8ku&ZUxgUzb5 zRHHigYcbylo&73eQ=NS3WEwTUu@K;Q^QkY>FIB3}KBl@g&!@hcrTLYs411!asqPv0 ztf*EUr3yNVr<8+XPraUoz3YGFsscY%=`4Jp_SeyGAm;1) zfH+Fm-vHjn9^7wc&QhS!-Jfpe?G@!f`;|q^R0kTT}yE#)G{hX0QNzSNE26-0p zsx8Z_R^|n}9L`oDFRE>EUN}oxI!jnHpXy4lbb5KwS)uoZ{QKvG=89#ES*ke}jYXSZ zYkE^NlH!%7W^*jY2gWQ@H!<0YiBVyh!r&%;!Z33xZi;uwP_`a@c*KVC@L4@JW@vWY z@)-{!ZzqM7j6_E)J!$Kv7U{L(!;z?FYsOU4=E5A082UgYF=da$&Gv(BhaySc7GeAX zk7~mr8A%A!oH8_1aKm4T3_bx7ZBU76XN4iTx5)iA@p#WVa~; z#C^M$a2rxxkTM~@D?+!VOo;VD(^4jceW+i`gorbwN||sA^=}d##fegSYn*CfMsMt-k-1N&My@qZ_- zO4)zs=-dLCVyTgzgH%ISSBAq zB$z6+3uQ8$(_)_SXS+!_KDhnMfLk_~zvr4^#4#_pW?9-4{%crQ%MymrlB-GuPl>4^ zEh_j$+zhtBHIvX2!qDjwiBAX%w-p~1BEjR9K8!ob;1h9cbO;<4D)@-%&+KE>iJQ`( z7}pVvZt8YvCYSUi=cjP74xS!JGQQ4T%9Fw#OE6@iS%dKja~=B=lZkQ7C?%+nLzJ0* zS*&F!5Pbtq#wsgYYU_sEtqp211XD`Ug6>xFVS!uS5HVq*?6$?*NHb>W7LSRTC5E^i r=Y}yJlQY;&Kjj1O`5(FXVj%kHqS literal 0 HcmV?d00001 diff --git a/test_pipeline_lowering_workflow_5/0_test_pipeline_lowering_workflow.mlir b/test_pipeline_lowering_workflow_5/0_test_pipeline_lowering_workflow.mlir new file mode 100644 index 0000000000..e31c55269d --- /dev/null +++ b/test_pipeline_lowering_workflow_5/0_test_pipeline_lowering_workflow.mlir @@ -0,0 +1,49 @@ +module @test_pipeline_lowering_workflow { + func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { + %0 = catalyst.launch_kernel @module_test_pipeline_lowering_workflow::@test_pipeline_lowering_workflow(%arg0) : (tensor) -> tensor + return %0 : tensor + } + module @module_test_pipeline_lowering_workflow { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<2> : tensor + %0 = quantum.alloc( 2) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %c_3 = stablehlo.constant dense<1> : tensor + %extracted_4 = tensor.extract %c_3[] : tensor + %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit + %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %extracted_7 = tensor.extract %c[] : tensor + %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit + %extracted_8 = tensor.extract %c_3[] : tensor + %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/1_EnforceRuntimeInvariantsPass.mlir b/test_pipeline_lowering_workflow_5/1_EnforceRuntimeInvariantsPass.mlir new file mode 100644 index 0000000000..8f33d0a2b3 --- /dev/null +++ b/test_pipeline_lowering_workflow_5/1_EnforceRuntimeInvariantsPass.mlir @@ -0,0 +1,31 @@ +module @test_pipeline_lowering_workflow { + func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { + %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor + return %0 : tensor + } + func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/2_HLOLoweringPass.mlir b/test_pipeline_lowering_workflow_5/2_HLOLoweringPass.mlir new file mode 100644 index 0000000000..8f33d0a2b3 --- /dev/null +++ b/test_pipeline_lowering_workflow_5/2_HLOLoweringPass.mlir @@ -0,0 +1,31 @@ +module @test_pipeline_lowering_workflow { + func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { + %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor + return %0 : tensor + } + func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/3_QuantumCompilationPass.mlir b/test_pipeline_lowering_workflow_5/3_QuantumCompilationPass.mlir new file mode 100644 index 0000000000..8f33d0a2b3 --- /dev/null +++ b/test_pipeline_lowering_workflow_5/3_QuantumCompilationPass.mlir @@ -0,0 +1,31 @@ +module @test_pipeline_lowering_workflow { + func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { + %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor + return %0 : tensor + } + func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/4_BufferizationPass.mlir b/test_pipeline_lowering_workflow_5/4_BufferizationPass.mlir new file mode 100644 index 0000000000..1f2d2c8f7f --- /dev/null +++ b/test_pipeline_lowering_workflow_5/4_BufferizationPass.mlir @@ -0,0 +1,44 @@ +module @test_pipeline_lowering_workflow { + func.func public @jit_test_pipeline_lowering_workflow(%arg0: memref) -> memref attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(3735928559 : index) : i64 + %1 = call @test_pipeline_lowering_workflow_0(%arg0) : (memref) -> memref + %2 = builtin.unrealized_conversion_cast %1 : memref to !llvm.struct<(ptr, ptr, i64)> + %3 = llvm.extractvalue %2[0] : !llvm.struct<(ptr, ptr, i64)> + %4 = llvm.ptrtoint %3 : !llvm.ptr to i64 + %5 = llvm.icmp "eq" %0, %4 : i64 + %6 = scf.if %5 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %1, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %1 : memref + } + return %6 : memref + } + func.func public @test_pipeline_lowering_workflow_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %5 = quantum.expval %4 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %5, %alloc[] : memref + %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit + quantum.dealloc %7 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/5_MLIRToLLVMDialect.mlir b/test_pipeline_lowering_workflow_5/5_MLIRToLLVMDialect.mlir new file mode 100644 index 0000000000..beb525fb8a --- /dev/null +++ b/test_pipeline_lowering_workflow_5/5_MLIRToLLVMDialect.mlir @@ -0,0 +1,116 @@ +module @test_pipeline_lowering_workflow { + llvm.func @__catalyst__rt__finalize() + llvm.func @__catalyst__rt__initialize(!llvm.ptr) + llvm.func @__catalyst__rt__device_release() + llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) + llvm.func @__catalyst__qis__Expval(i64) -> f64 + llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 + llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr + llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr + llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} + llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) + llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr + llvm.func @jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.zero : !llvm.ptr + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(3735928559 : index) : i64 + %4 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %5 = llvm.call @test_pipeline_lowering_workflow_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %6 = llvm.extractvalue %5[0] : !llvm.struct<(ptr, ptr, i64)> + %7 = llvm.ptrtoint %6 : !llvm.ptr to i64 + %8 = llvm.icmp "eq" %3, %7 : i64 + llvm.cond_br %8, ^bb1, ^bb2 + ^bb1: // pred: ^bb0 + %9 = llvm.getelementptr %1[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %10 = llvm.ptrtoint %9 : !llvm.ptr to i64 + %11 = llvm.call @_mlir_memref_to_llvm_alloc(%10) : (i64) -> !llvm.ptr + %12 = llvm.insertvalue %11, %4[0] : !llvm.struct<(ptr, ptr, i64)> + %13 = llvm.insertvalue %11, %12[1] : !llvm.struct<(ptr, ptr, i64)> + %14 = llvm.insertvalue %0, %13[2] : !llvm.struct<(ptr, ptr, i64)> + %15 = llvm.getelementptr %1[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %16 = llvm.ptrtoint %15 : !llvm.ptr to i64 + %17 = llvm.mul %16, %2 : i64 + %18 = llvm.extractvalue %5[1] : !llvm.struct<(ptr, ptr, i64)> + %19 = llvm.extractvalue %5[2] : !llvm.struct<(ptr, ptr, i64)> + %20 = llvm.getelementptr inbounds %18[%19] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%11, %20, %17) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb3(%14 : !llvm.struct<(ptr, ptr, i64)>) + ^bb2: // pred: ^bb0 + llvm.br ^bb3(%5 : !llvm.struct<(ptr, ptr, i64)>) + ^bb3(%21: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 + llvm.br ^bb4 + ^bb4: // pred: ^bb3 + llvm.return %21 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @_catalyst_pyface_jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { + %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr)> + %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr)> + llvm.call @_catalyst_ciface_jit_test_pipeline_lowering_workflow(%arg0, %1) : (!llvm.ptr, !llvm.ptr) -> () + llvm.return + } + llvm.func @_catalyst_ciface_jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr, i64)> + %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr, i64)> + %2 = llvm.extractvalue %0[1] : !llvm.struct<(ptr, ptr, i64)> + %3 = llvm.extractvalue %0[2] : !llvm.struct<(ptr, ptr, i64)> + %4 = llvm.call @jit_test_pipeline_lowering_workflow(%1, %2, %3) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + llvm.store %4, %arg0 : !llvm.struct<(ptr, ptr, i64)>, !llvm.ptr + llvm.return + } + llvm.func internal @test_pipeline_lowering_workflow_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(1 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(2 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr + %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 + %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 + %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 + %24 = llvm.add %23, %1 : i64 + %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr + %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 + %27 = llvm.sub %1, %2 : i64 + %28 = llvm.add %26, %27 : i64 + %29 = llvm.urem %28, %1 : i64 + %30 = llvm.sub %28, %29 : i64 + %31 = llvm.inttoptr %30 : i64 to !llvm.ptr + %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %21, %31 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @setup() { + %0 = llvm.mlir.zero : !llvm.ptr + llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @teardown() { + llvm.call @__catalyst__rt__finalize() : () -> () + llvm.return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/6_llvm_ir.ll b/test_pipeline_lowering_workflow_5/6_llvm_ir.ll new file mode 100644 index 0000000000..c5b40ab21d --- /dev/null +++ b/test_pipeline_lowering_workflow_5/6_llvm_ir.ll @@ -0,0 +1,118 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" + +@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" +@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" +@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" + +declare void @__catalyst__rt__finalize() + +declare void @__catalyst__rt__initialize(ptr) + +declare void @__catalyst__rt__device_release() + +declare void @__catalyst__rt__qubit_release_array(ptr) + +declare double @__catalyst__qis__Expval(i64) + +declare i64 @__catalyst__qis__NamedObs(i64, ptr) + +declare void @__catalyst__qis__RX(double, ptr, ptr) + +declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) + +declare ptr @__catalyst__rt__qubit_allocate_array(i64) + +declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) + +declare ptr @_mlir_memref_to_llvm_alloc(i64) + +define { ptr, ptr, i64 } @jit_test_pipeline_lowering_workflow(ptr %0, ptr %1, i64 %2) { + %4 = call { ptr, ptr, i64 } @test_pipeline_lowering_workflow_0(ptr %0, ptr %1, i64 %2) + %5 = extractvalue { ptr, ptr, i64 } %4, 0 + %6 = ptrtoint ptr %5 to i64 + %7 = icmp eq i64 3735928559, %6 + br i1 %7, label %8, label %16 + +8: ; preds = %3 + %9 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %10 = insertvalue { ptr, ptr, i64 } poison, ptr %9, 0 + %11 = insertvalue { ptr, ptr, i64 } %10, ptr %9, 1 + %12 = insertvalue { ptr, ptr, i64 } %11, i64 0, 2 + %13 = extractvalue { ptr, ptr, i64 } %4, 1 + %14 = extractvalue { ptr, ptr, i64 } %4, 2 + %15 = getelementptr inbounds double, ptr %13, i64 %14 + call void @llvm.memcpy.p0.p0.i64(ptr %9, ptr %15, i64 8, i1 false) + br label %17 + +16: ; preds = %3 + br label %17 + +17: ; preds = %8, %16 + %18 = phi { ptr, ptr, i64 } [ %4, %16 ], [ %12, %8 ] + br label %19 + +19: ; preds = %17 + ret { ptr, ptr, i64 } %18 +} + +define void @_catalyst_pyface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %1) { + %3 = load { ptr, ptr }, ptr %1, align 8 + %4 = extractvalue { ptr, ptr } %3, 0 + call void @_catalyst_ciface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %4) + ret void +} + +define void @_catalyst_ciface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %1) { + %3 = load { ptr, ptr, i64 }, ptr %1, align 8 + %4 = extractvalue { ptr, ptr, i64 } %3, 0 + %5 = extractvalue { ptr, ptr, i64 } %3, 1 + %6 = extractvalue { ptr, ptr, i64 } %3, 2 + %7 = call { ptr, ptr, i64 } @jit_test_pipeline_lowering_workflow(ptr %4, ptr %5, i64 %6) + store { ptr, ptr, i64 } %7, ptr %0, align 8 + ret void +} + +define internal { ptr, ptr, i64 } @test_pipeline_lowering_workflow_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) + %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) + %10 = call double @__catalyst__qis__Expval(i64 %9) + %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %12 = ptrtoint ptr %11 to i64 + %13 = add i64 %12, 63 + %14 = urem i64 %13, 64 + %15 = sub i64 %13, %14 + %16 = inttoptr i64 %15 to ptr + %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 + %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 + %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 + store double %10, ptr %16, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %19 +} + +define void @setup() { + call void @__catalyst__rt__initialize(ptr null) + ret void +} + +define void @teardown() { + call void @__catalyst__rt__finalize() + ret void +} + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 + +attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_pipeline_lowering_workflow_5/test_pipeline_lowering_workflow.o b/test_pipeline_lowering_workflow_5/test_pipeline_lowering_workflow.o new file mode 100644 index 0000000000000000000000000000000000000000..caced91192178fff3af454d907c7de877128823c GIT binary patch literal 3104 zcmc&$T}&KR6h6ZOT?7}jXsd0?)|x8smd&vf_7U?uBJ3CiTUWz4OgE z-#O==duHa|{raz8{%#>M2*Q_ojBp(;Q4GjK7;pNlukO2KH~`YcF%YdE!aWZ~lMtSq z^VlO0A%@S73~Q|lRUXdAx2ugr4>Da(iws(XNT!|aZo+-}RGu3upbLfQT6B(Tc`GMWRF&oYA#lt%kPs;X9#4(OE5pBSTcpAiD39ErA=w1xw?pC&!jBhFn z4SB@9Tj-#2@f4MBc2c?Y!+YOe{qEZD9R~eu)X{L*SR5*Z!jG}vPo0T!=~SZpV~ExY zp^mj;sA=scMmTrz&n^S;hmq$9l?%tHj2hbu@GrvuW(P(Uhc&ks4ud-a`!S3|h-*e% zE8!mY<^=8&<;ueOJnCFo4~ZLss%F#^95^3^pFYy=x2=d;L3e$MUZxCiz5Vh9}3GR6vOTRsUy%a_jqZ(*Ic(4VbP zhu?#K3i?q%yr(7%RS&kVWbkmdZr0JP7Fz3tmVlV zzSv9Vq|C-M(s6RO=}2MgnK)oa5tpaOEKlf!r^j<(t4jDRxL050E}`uHw*~7yenYuF zb3lB3@WJZud|&+cif=z4{x`+99l$F)8S_JA%$+dWS~@5SU)~G0wgb^?p#I3{$Hqr^ zRf&#caLwz=hy8u&i?p#1^DkpuQ9S$l(jSRx{#6(j6~C!y%rU6>4`CZsyjmYoRsQSX z6N=aC(EJ}*_hF*g77($qb>RKL>p+|bu~py^AfHXx(_(J`BfvQza>b^At-wL0_W>V( z{sizo;G;mC2LsUndyfP0a0ZSB*xL?7qXyan?A=1G_aKgI#$FZc2J-y8x56cMCBVi- zg`)}+3Zn`E?BBQ!#Fl-65&M1QiqaXeKSvgo&Itd=sL~lRXC$F?Mr`?!<4R{losmya zd<217K2>_XvSF{L2*xM|OD9i)`-IZjjdgAU%lp7;{TH7U2fR5jewAAQxn7^98R>S{_$ZGzB8eZ1uuh-~L z*2KS3qu;LaC-L8QOo2ZldealGC)B=W+IAXtDNNTjbNDxPM=w{}(#-BU?PSX2Cd{N1 z7qJ6+65DCU%1GPd%`!bJUF^zYHtk-TfQHmNQAz7AqISdlvd86&g&8f!^7dAH*~$uW z0f)r+3u9RlcQ_YBR(jJJLZzlVo}P8?5PyCyGh^C&32xQ|P7d3em-`tm#5#aewW{vz zkM(;lCMAv`Tc)Ig{&}wG8HZ=ewp@{tDOXMiFD-0)CMEo5MdJTC(e}I(F-Q41TeHlbI{R8t>zFz) -> tensor attributes {llvm.emit_c_interface} { + %0 = catalyst.launch_kernel @module_test_pipeline_lowering_workflow::@test_pipeline_lowering_workflow(%arg0) : (tensor) -> tensor + return %0 : tensor + } + module @module_test_pipeline_lowering_workflow { + module attributes {transform.with_named_sequence} { + transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { + %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> + transform.yield + } + } + func.func public @test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c = stablehlo.constant dense<0> : tensor + %extracted = tensor.extract %c[] : tensor + quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %c_0 = stablehlo.constant dense<2> : tensor + %0 = quantum.alloc( 2) : !quantum.reg + %extracted_1 = tensor.extract %c[] : tensor + %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit + %extracted_2 = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit + %c_3 = stablehlo.constant dense<1> : tensor + %extracted_4 = tensor.extract %c_3[] : tensor + %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit + %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit + %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %extracted_7 = tensor.extract %c[] : tensor + %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit + %extracted_8 = tensor.extract %c_3[] : tensor + %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/1_EnforceRuntimeInvariantsPass.mlir b/test_pipeline_lowering_workflow_6/1_EnforceRuntimeInvariantsPass.mlir new file mode 100644 index 0000000000..8f33d0a2b3 --- /dev/null +++ b/test_pipeline_lowering_workflow_6/1_EnforceRuntimeInvariantsPass.mlir @@ -0,0 +1,31 @@ +module @test_pipeline_lowering_workflow { + func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { + %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor + return %0 : tensor + } + func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/2_HLOLoweringPass.mlir b/test_pipeline_lowering_workflow_6/2_HLOLoweringPass.mlir new file mode 100644 index 0000000000..8f33d0a2b3 --- /dev/null +++ b/test_pipeline_lowering_workflow_6/2_HLOLoweringPass.mlir @@ -0,0 +1,31 @@ +module @test_pipeline_lowering_workflow { + func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { + %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor + return %0 : tensor + } + func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/3_QuantumCompilationPass.mlir b/test_pipeline_lowering_workflow_6/3_QuantumCompilationPass.mlir new file mode 100644 index 0000000000..8f33d0a2b3 --- /dev/null +++ b/test_pipeline_lowering_workflow_6/3_QuantumCompilationPass.mlir @@ -0,0 +1,31 @@ +module @test_pipeline_lowering_workflow { + func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { + %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor + return %0 : tensor + } + func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %extracted = tensor.extract %arg0[] : tensor + %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit + %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %4 = quantum.expval %3 : f64 + %from_elements = tensor.from_elements %4 : tensor + %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit + quantum.dealloc %6 : !quantum.reg + quantum.device_release + return %from_elements : tensor + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/4_BufferizationPass.mlir b/test_pipeline_lowering_workflow_6/4_BufferizationPass.mlir new file mode 100644 index 0000000000..1f2d2c8f7f --- /dev/null +++ b/test_pipeline_lowering_workflow_6/4_BufferizationPass.mlir @@ -0,0 +1,44 @@ +module @test_pipeline_lowering_workflow { + func.func public @jit_test_pipeline_lowering_workflow(%arg0: memref) -> memref attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(3735928559 : index) : i64 + %1 = call @test_pipeline_lowering_workflow_0(%arg0) : (memref) -> memref + %2 = builtin.unrealized_conversion_cast %1 : memref to !llvm.struct<(ptr, ptr, i64)> + %3 = llvm.extractvalue %2[0] : !llvm.struct<(ptr, ptr, i64)> + %4 = llvm.ptrtoint %3 : !llvm.ptr to i64 + %5 = llvm.icmp "eq" %0, %4 : i64 + %6 = scf.if %5 -> (memref) { + %alloc = memref.alloc() : memref + memref.copy %1, %alloc : memref to memref + scf.yield %alloc : memref + } else { + scf.yield %1 : memref + } + return %6 : memref + } + func.func public @test_pipeline_lowering_workflow_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { + %c0_i64 = arith.constant 0 : i64 + quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] + %0 = quantum.alloc( 2) : !quantum.reg + %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit + %2 = memref.load %arg0[] : memref + %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit + %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit + %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs + %5 = quantum.expval %4 : f64 + %alloc = memref.alloc() {alignment = 64 : i64} : memref + memref.store %5, %alloc[] : memref + %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit + %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit + quantum.dealloc %7 : !quantum.reg + quantum.device_release + return %alloc : memref + } + func.func @setup() { + quantum.init + return + } + func.func @teardown() { + quantum.finalize + return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/5_MLIRToLLVMDialect.mlir b/test_pipeline_lowering_workflow_6/5_MLIRToLLVMDialect.mlir new file mode 100644 index 0000000000..beb525fb8a --- /dev/null +++ b/test_pipeline_lowering_workflow_6/5_MLIRToLLVMDialect.mlir @@ -0,0 +1,116 @@ +module @test_pipeline_lowering_workflow { + llvm.func @__catalyst__rt__finalize() + llvm.func @__catalyst__rt__initialize(!llvm.ptr) + llvm.func @__catalyst__rt__device_release() + llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) + llvm.func @__catalyst__qis__Expval(i64) -> f64 + llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 + llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) + llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr + llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr + llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} + llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} + llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) + llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr + llvm.func @jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.zero : !llvm.ptr + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(3735928559 : index) : i64 + %4 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %5 = llvm.call @test_pipeline_lowering_workflow_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + %6 = llvm.extractvalue %5[0] : !llvm.struct<(ptr, ptr, i64)> + %7 = llvm.ptrtoint %6 : !llvm.ptr to i64 + %8 = llvm.icmp "eq" %3, %7 : i64 + llvm.cond_br %8, ^bb1, ^bb2 + ^bb1: // pred: ^bb0 + %9 = llvm.getelementptr %1[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %10 = llvm.ptrtoint %9 : !llvm.ptr to i64 + %11 = llvm.call @_mlir_memref_to_llvm_alloc(%10) : (i64) -> !llvm.ptr + %12 = llvm.insertvalue %11, %4[0] : !llvm.struct<(ptr, ptr, i64)> + %13 = llvm.insertvalue %11, %12[1] : !llvm.struct<(ptr, ptr, i64)> + %14 = llvm.insertvalue %0, %13[2] : !llvm.struct<(ptr, ptr, i64)> + %15 = llvm.getelementptr %1[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %16 = llvm.ptrtoint %15 : !llvm.ptr to i64 + %17 = llvm.mul %16, %2 : i64 + %18 = llvm.extractvalue %5[1] : !llvm.struct<(ptr, ptr, i64)> + %19 = llvm.extractvalue %5[2] : !llvm.struct<(ptr, ptr, i64)> + %20 = llvm.getelementptr inbounds %18[%19] : (!llvm.ptr, i64) -> !llvm.ptr, f64 + "llvm.intr.memcpy"(%11, %20, %17) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () + llvm.br ^bb3(%14 : !llvm.struct<(ptr, ptr, i64)>) + ^bb2: // pred: ^bb0 + llvm.br ^bb3(%5 : !llvm.struct<(ptr, ptr, i64)>) + ^bb3(%21: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 + llvm.br ^bb4 + ^bb4: // pred: ^bb3 + llvm.return %21 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @_catalyst_pyface_jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { + %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr)> + %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr)> + llvm.call @_catalyst_ciface_jit_test_pipeline_lowering_workflow(%arg0, %1) : (!llvm.ptr, !llvm.ptr) -> () + llvm.return + } + llvm.func @_catalyst_ciface_jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { + %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr, i64)> + %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr, i64)> + %2 = llvm.extractvalue %0[1] : !llvm.struct<(ptr, ptr, i64)> + %3 = llvm.extractvalue %0[2] : !llvm.struct<(ptr, ptr, i64)> + %4 = llvm.call @jit_test_pipeline_lowering_workflow(%1, %2, %3) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> + llvm.store %4, %arg0 : !llvm.struct<(ptr, ptr, i64)>, !llvm.ptr + llvm.return + } + llvm.func internal @test_pipeline_lowering_workflow_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { + %0 = llvm.mlir.constant(0 : index) : i64 + %1 = llvm.mlir.constant(64 : index) : i64 + %2 = llvm.mlir.constant(1 : index) : i64 + %3 = llvm.mlir.constant(1 : i64) : i64 + %4 = llvm.mlir.zero : !llvm.ptr + %5 = llvm.mlir.constant(2 : i64) : i64 + %6 = llvm.mlir.constant(false) : i1 + %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr + %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr + %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr + %10 = llvm.mlir.constant(0 : i64) : i64 + %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> + %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> + %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> + %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> + llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () + %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr + %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr + %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr + %18 = llvm.load %arg1 : !llvm.ptr -> f64 + llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () + %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr + %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 + %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 + %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 + %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 + %24 = llvm.add %23, %1 : i64 + %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr + %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 + %27 = llvm.sub %1, %2 : i64 + %28 = llvm.add %26, %27 : i64 + %29 = llvm.urem %28, %1 : i64 + %30 = llvm.sub %28, %29 : i64 + %31 = llvm.inttoptr %30 : i64 to !llvm.ptr + %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> + %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> + %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> + llvm.store %21, %31 : f64, !llvm.ptr + llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () + llvm.call @__catalyst__rt__device_release() : () -> () + llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> + } + llvm.func @setup() { + %0 = llvm.mlir.zero : !llvm.ptr + llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () + llvm.return + } + llvm.func @teardown() { + llvm.call @__catalyst__rt__finalize() : () -> () + llvm.return + } +} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/6_llvm_ir.ll b/test_pipeline_lowering_workflow_6/6_llvm_ir.ll new file mode 100644 index 0000000000..c5b40ab21d --- /dev/null +++ b/test_pipeline_lowering_workflow_6/6_llvm_ir.ll @@ -0,0 +1,118 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" + +@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" +@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" +@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" + +declare void @__catalyst__rt__finalize() + +declare void @__catalyst__rt__initialize(ptr) + +declare void @__catalyst__rt__device_release() + +declare void @__catalyst__rt__qubit_release_array(ptr) + +declare double @__catalyst__qis__Expval(i64) + +declare i64 @__catalyst__qis__NamedObs(i64, ptr) + +declare void @__catalyst__qis__RX(double, ptr, ptr) + +declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) + +declare ptr @__catalyst__rt__qubit_allocate_array(i64) + +declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) + +declare ptr @_mlir_memref_to_llvm_alloc(i64) + +define { ptr, ptr, i64 } @jit_test_pipeline_lowering_workflow(ptr %0, ptr %1, i64 %2) { + %4 = call { ptr, ptr, i64 } @test_pipeline_lowering_workflow_0(ptr %0, ptr %1, i64 %2) + %5 = extractvalue { ptr, ptr, i64 } %4, 0 + %6 = ptrtoint ptr %5 to i64 + %7 = icmp eq i64 3735928559, %6 + br i1 %7, label %8, label %16 + +8: ; preds = %3 + %9 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) + %10 = insertvalue { ptr, ptr, i64 } poison, ptr %9, 0 + %11 = insertvalue { ptr, ptr, i64 } %10, ptr %9, 1 + %12 = insertvalue { ptr, ptr, i64 } %11, i64 0, 2 + %13 = extractvalue { ptr, ptr, i64 } %4, 1 + %14 = extractvalue { ptr, ptr, i64 } %4, 2 + %15 = getelementptr inbounds double, ptr %13, i64 %14 + call void @llvm.memcpy.p0.p0.i64(ptr %9, ptr %15, i64 8, i1 false) + br label %17 + +16: ; preds = %3 + br label %17 + +17: ; preds = %8, %16 + %18 = phi { ptr, ptr, i64 } [ %4, %16 ], [ %12, %8 ] + br label %19 + +19: ; preds = %17 + ret { ptr, ptr, i64 } %18 +} + +define void @_catalyst_pyface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %1) { + %3 = load { ptr, ptr }, ptr %1, align 8 + %4 = extractvalue { ptr, ptr } %3, 0 + call void @_catalyst_ciface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %4) + ret void +} + +define void @_catalyst_ciface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %1) { + %3 = load { ptr, ptr, i64 }, ptr %1, align 8 + %4 = extractvalue { ptr, ptr, i64 } %3, 0 + %5 = extractvalue { ptr, ptr, i64 } %3, 1 + %6 = extractvalue { ptr, ptr, i64 } %3, 2 + %7 = call { ptr, ptr, i64 } @jit_test_pipeline_lowering_workflow(ptr %4, ptr %5, i64 %6) + store { ptr, ptr, i64 } %7, ptr %0, align 8 + ret void +} + +define internal { ptr, ptr, i64 } @test_pipeline_lowering_workflow_0(ptr %0, ptr %1, i64 %2) { + call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) + %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) + %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) + %6 = load ptr, ptr %5, align 8 + %7 = load double, ptr %1, align 8 + call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) + %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) + %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) + %10 = call double @__catalyst__qis__Expval(i64 %9) + %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) + %12 = ptrtoint ptr %11 to i64 + %13 = add i64 %12, 63 + %14 = urem i64 %13, 64 + %15 = sub i64 %13, %14 + %16 = inttoptr i64 %15 to ptr + %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 + %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 + %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 + store double %10, ptr %16, align 8 + call void @__catalyst__rt__qubit_release_array(ptr %4) + call void @__catalyst__rt__device_release() + ret { ptr, ptr, i64 } %19 +} + +define void @setup() { + call void @__catalyst__rt__initialize(ptr null) + ret void +} + +define void @teardown() { + call void @__catalyst__rt__finalize() + ret void +} + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 + +attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_pipeline_lowering_workflow_6/test_pipeline_lowering_workflow.o b/test_pipeline_lowering_workflow_6/test_pipeline_lowering_workflow.o new file mode 100644 index 0000000000000000000000000000000000000000..caced91192178fff3af454d907c7de877128823c GIT binary patch literal 3104 zcmc&$T}&KR6h6ZOT?7}jXsd0?)|x8smd&vf_7U?uBJ3CiTUWz4OgE z-#O==duHa|{raz8{%#>M2*Q_ojBp(;Q4GjK7;pNlukO2KH~`YcF%YdE!aWZ~lMtSq z^VlO0A%@S73~Q|lRUXdAx2ugr4>Da(iws(XNT!|aZo+-}RGu3upbLfQT6B(Tc`GMWRF&oYA#lt%kPs;X9#4(OE5pBSTcpAiD39ErA=w1xw?pC&!jBhFn z4SB@9Tj-#2@f4MBc2c?Y!+YOe{qEZD9R~eu)X{L*SR5*Z!jG}vPo0T!=~SZpV~ExY zp^mj;sA=scMmTrz&n^S;hmq$9l?%tHj2hbu@GrvuW(P(Uhc&ks4ud-a`!S3|h-*e% zE8!mY<^=8&<;ueOJnCFo4~ZLss%F#^95^3^pFYy=x2=d;L3e$MUZxCiz5Vh9}3GR6vOTRsUy%a_jqZ(*Ic(4VbP zhu?#K3i?q%yr(7%RS&kVWbkmdZr0JP7Fz3tmVlV zzSv9Vq|C-M(s6RO=}2MgnK)oa5tpaOEKlf!r^j<(t4jDRxL050E}`uHw*~7yenYuF zb3lB3@WJZud|&+cif=z4{x`+99l$F)8S_JA%$+dWS~@5SU)~G0wgb^?p#I3{$Hqr^ zRf&#caLwz=hy8u&i?p#1^DkpuQ9S$l(jSRx{#6(j6~C!y%rU6>4`CZsyjmYoRsQSX z6N=aC(EJ}*_hF*g77($qb>RKL>p+|bu~py^AfHXx(_(J`BfvQza>b^At-wL0_W>V( z{sizo;G;mC2LsUndyfP0a0ZSB*xL?7qXyan?A=1G_aKgI#$FZc2J-y8x56cMCBVi- zg`)}+3Zn`E?BBQ!#Fl-65&M1QiqaXeKSvgo&Itd=sL~lRXC$F?Mr`?!<4R{losmya zd<217K2>_XvSF{L2*xM|OD9i)`-IZjjdgAU%lp7;{TH7U2fR5jewAAQxn7^98R>S{_$ZGzB8eZ1uuh-~L z*2KS3qu;LaC-L8QOo2ZldealGC)B=W+IAXtDNNTjbNDxPM=w{}(#-BU?PSX2Cd{N1 z7qJ6+65DCU%1GPd%`!bJUF^zYHtk-TfQHmNQAz7AqISdlvd86&g&8f!^7dAH*~$uW z0f)r+3u9RlcQ_YBR(jJJLZzlVo}P8?5PyCyGh^C&32xQ|P7d3em-`tm#5#aewW{vz zkM(;lCMAv`Tc)Ig{&}wG8HZ=ewp@{tDOXMiFD-0)CMEo5MdJTC(e}I(F-Q41TeHlbI{R8t>zFz Date: Thu, 20 Nov 2025 14:00:37 -0500 Subject: [PATCH 23/24] delete test files --- global_wf_5/0_global_wf.mlir | 86 ------ .../1_EnforceRuntimeInvariantsPass.mlir | 50 ---- global_wf_5/2_HLOLoweringPass.mlir | 50 ---- global_wf_5/3_QuantumCompilationPass.mlir | 50 ---- global_wf_5/4_BufferizationPass.mlir | 76 ------ global_wf_5/5_MLIRToLLVMDialect.mlir | 184 ------------- global_wf_5/6_llvm_ir.ll | 165 ----------- global_wf_5/global_wf.o | Bin 3848 -> 0 bytes global_wf_6/0_global_wf.mlir | 85 ------ .../1_EnforceRuntimeInvariantsPass.mlir | 52 ---- global_wf_6/2_HLOLoweringPass.mlir | 52 ---- global_wf_6/3_QuantumCompilationPass.mlir | 52 ---- global_wf_6/4_BufferizationPass.mlir | 78 ------ global_wf_6/5_MLIRToLLVMDialect.mlir | 188 ------------- global_wf_6/6_llvm_ir.ll | 170 ------------ global_wf_6/global_wf.o | Bin 3904 -> 0 bytes ...ncel_inverses_keep_original_workflow0.mlir | 43 --- .../1_EnforceRuntimeInvariantsPass.mlir | 32 --- .../2_HLOLoweringPass.mlir | 32 --- .../3_QuantumCompilationPass.mlir | 32 --- .../4_BufferizationPass.mlir | 46 ---- .../5_MLIRToLLVMDialect.mlir | 115 -------- .../6_llvm_ir.ll | 116 -------- ..._cancel_inverses_keep_original_workflow0.o | Bin 3320 -> 0 bytes ...ncel_inverses_keep_original_workflow1.mlir | 44 --- .../1_EnforceRuntimeInvariantsPass.mlir | 30 -- .../2_HLOLoweringPass.mlir | 30 -- .../3_QuantumCompilationPass.mlir | 30 -- .../4_BufferizationPass.mlir | 44 --- .../5_MLIRToLLVMDialect.mlir | 112 -------- .../6_llvm_ir.ll | 112 -------- ..._cancel_inverses_keep_original_workflow1.o | Bin 3192 -> 0 bytes ...ncel_inverses_keep_original_workflow2.mlir | 73 ----- .../1_EnforceRuntimeInvariantsPass.mlir | 48 ---- .../2_HLOLoweringPass.mlir | 48 ---- .../3_QuantumCompilationPass.mlir | 48 ---- .../4_BufferizationPass.mlir | 74 ----- .../5_MLIRToLLVMDialect.mlir | 185 ------------- .../6_llvm_ir.ll | 167 ------------ ..._cancel_inverses_keep_original_workflow2.o | Bin 3960 -> 0 bytes ...s_lowering_transform_applied_workflow.mlir | 102 ------- .../1_EnforceRuntimeInvariantsPass.mlir | 65 ----- .../2_HLOLoweringPass.mlir | 65 ----- .../3_QuantumCompilationPass.mlir | 65 ----- .../4_BufferizationPass.mlir | 102 ------- .../5_MLIRToLLVMDialect.mlir | 258 ------------------ .../6_llvm_ir.ll | 224 --------------- ...rses_lowering_transform_applied_workflow.o | Bin 4640 -> 0 bytes ...eline_lowering_keep_original_workflow.mlir | 83 ------ .../1_EnforceRuntimeInvariantsPass.mlir | 51 ---- .../2_HLOLoweringPass.mlir | 51 ---- .../3_QuantumCompilationPass.mlir | 51 ---- .../4_BufferizationPass.mlir | 76 ------ .../5_MLIRToLLVMDialect.mlir | 191 ------------- .../6_llvm_ir.ll | 175 ------------ ...pipeline_lowering_keep_original_workflow.o | Bin 3880 -> 0 bytes .../0_test_pipeline_lowering_workflow.mlir | 49 ---- .../1_EnforceRuntimeInvariantsPass.mlir | 31 --- .../2_HLOLoweringPass.mlir | 31 --- .../3_QuantumCompilationPass.mlir | 31 --- .../4_BufferizationPass.mlir | 44 --- .../5_MLIRToLLVMDialect.mlir | 116 -------- .../6_llvm_ir.ll | 118 -------- .../test_pipeline_lowering_workflow.o | Bin 3104 -> 0 bytes .../0_test_pipeline_lowering_workflow.mlir | 49 ---- .../1_EnforceRuntimeInvariantsPass.mlir | 31 --- .../2_HLOLoweringPass.mlir | 31 --- .../3_QuantumCompilationPass.mlir | 31 --- .../4_BufferizationPass.mlir | 44 --- .../5_MLIRToLLVMDialect.mlir | 116 -------- .../6_llvm_ir.ll | 118 -------- .../test_pipeline_lowering_workflow.o | Bin 3104 -> 0 bytes 72 files changed, 5198 deletions(-) delete mode 100644 global_wf_5/0_global_wf.mlir delete mode 100644 global_wf_5/1_EnforceRuntimeInvariantsPass.mlir delete mode 100644 global_wf_5/2_HLOLoweringPass.mlir delete mode 100644 global_wf_5/3_QuantumCompilationPass.mlir delete mode 100644 global_wf_5/4_BufferizationPass.mlir delete mode 100644 global_wf_5/5_MLIRToLLVMDialect.mlir delete mode 100644 global_wf_5/6_llvm_ir.ll delete mode 100644 global_wf_5/global_wf.o delete mode 100644 global_wf_6/0_global_wf.mlir delete mode 100644 global_wf_6/1_EnforceRuntimeInvariantsPass.mlir delete mode 100644 global_wf_6/2_HLOLoweringPass.mlir delete mode 100644 global_wf_6/3_QuantumCompilationPass.mlir delete mode 100644 global_wf_6/4_BufferizationPass.mlir delete mode 100644 global_wf_6/5_MLIRToLLVMDialect.mlir delete mode 100644 global_wf_6/6_llvm_ir.ll delete mode 100644 global_wf_6/global_wf.o delete mode 100644 test_cancel_inverses_keep_original_workflow0_2/0_test_cancel_inverses_keep_original_workflow0.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow0_2/1_EnforceRuntimeInvariantsPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow0_2/2_HLOLoweringPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow0_2/3_QuantumCompilationPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow0_2/4_BufferizationPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow0_2/5_MLIRToLLVMDialect.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow0_2/6_llvm_ir.ll delete mode 100644 test_cancel_inverses_keep_original_workflow0_2/test_cancel_inverses_keep_original_workflow0.o delete mode 100644 test_cancel_inverses_keep_original_workflow1_2/0_test_cancel_inverses_keep_original_workflow1.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow1_2/1_EnforceRuntimeInvariantsPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow1_2/2_HLOLoweringPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow1_2/3_QuantumCompilationPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow1_2/4_BufferizationPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow1_2/5_MLIRToLLVMDialect.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow1_2/6_llvm_ir.ll delete mode 100644 test_cancel_inverses_keep_original_workflow1_2/test_cancel_inverses_keep_original_workflow1.o delete mode 100644 test_cancel_inverses_keep_original_workflow2_2/0_test_cancel_inverses_keep_original_workflow2.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow2_2/1_EnforceRuntimeInvariantsPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow2_2/2_HLOLoweringPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow2_2/3_QuantumCompilationPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow2_2/4_BufferizationPass.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow2_2/5_MLIRToLLVMDialect.mlir delete mode 100644 test_cancel_inverses_keep_original_workflow2_2/6_llvm_ir.ll delete mode 100644 test_cancel_inverses_keep_original_workflow2_2/test_cancel_inverses_keep_original_workflow2.o delete mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/0_test_cancel_inverses_lowering_transform_applied_workflow.mlir delete mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/1_EnforceRuntimeInvariantsPass.mlir delete mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/2_HLOLoweringPass.mlir delete mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/3_QuantumCompilationPass.mlir delete mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/4_BufferizationPass.mlir delete mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/5_MLIRToLLVMDialect.mlir delete mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/6_llvm_ir.ll delete mode 100644 test_cancel_inverses_lowering_transform_applied_workflow_2/test_cancel_inverses_lowering_transform_applied_workflow.o delete mode 100644 test_pipeline_lowering_keep_original_workflow_3/0_test_pipeline_lowering_keep_original_workflow.mlir delete mode 100644 test_pipeline_lowering_keep_original_workflow_3/1_EnforceRuntimeInvariantsPass.mlir delete mode 100644 test_pipeline_lowering_keep_original_workflow_3/2_HLOLoweringPass.mlir delete mode 100644 test_pipeline_lowering_keep_original_workflow_3/3_QuantumCompilationPass.mlir delete mode 100644 test_pipeline_lowering_keep_original_workflow_3/4_BufferizationPass.mlir delete mode 100644 test_pipeline_lowering_keep_original_workflow_3/5_MLIRToLLVMDialect.mlir delete mode 100644 test_pipeline_lowering_keep_original_workflow_3/6_llvm_ir.ll delete mode 100644 test_pipeline_lowering_keep_original_workflow_3/test_pipeline_lowering_keep_original_workflow.o delete mode 100644 test_pipeline_lowering_workflow_5/0_test_pipeline_lowering_workflow.mlir delete mode 100644 test_pipeline_lowering_workflow_5/1_EnforceRuntimeInvariantsPass.mlir delete mode 100644 test_pipeline_lowering_workflow_5/2_HLOLoweringPass.mlir delete mode 100644 test_pipeline_lowering_workflow_5/3_QuantumCompilationPass.mlir delete mode 100644 test_pipeline_lowering_workflow_5/4_BufferizationPass.mlir delete mode 100644 test_pipeline_lowering_workflow_5/5_MLIRToLLVMDialect.mlir delete mode 100644 test_pipeline_lowering_workflow_5/6_llvm_ir.ll delete mode 100644 test_pipeline_lowering_workflow_5/test_pipeline_lowering_workflow.o delete mode 100644 test_pipeline_lowering_workflow_6/0_test_pipeline_lowering_workflow.mlir delete mode 100644 test_pipeline_lowering_workflow_6/1_EnforceRuntimeInvariantsPass.mlir delete mode 100644 test_pipeline_lowering_workflow_6/2_HLOLoweringPass.mlir delete mode 100644 test_pipeline_lowering_workflow_6/3_QuantumCompilationPass.mlir delete mode 100644 test_pipeline_lowering_workflow_6/4_BufferizationPass.mlir delete mode 100644 test_pipeline_lowering_workflow_6/5_MLIRToLLVMDialect.mlir delete mode 100644 test_pipeline_lowering_workflow_6/6_llvm_ir.ll delete mode 100644 test_pipeline_lowering_workflow_6/test_pipeline_lowering_workflow.o diff --git a/global_wf_5/0_global_wf.mlir b/global_wf_5/0_global_wf.mlir deleted file mode 100644 index 68bd3dd410..0000000000 --- a/global_wf_5/0_global_wf.mlir +++ /dev/null @@ -1,86 +0,0 @@ -module @global_wf { - func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.200000e+00> : tensor - %0 = catalyst.launch_kernel @module_g::@g(%cst) : (tensor) -> tensor - %1 = catalyst.launch_kernel @module_h::@h(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - module @module_g { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @g(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<2> : tensor - %0 = quantum.alloc( 2) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %c_3 = stablehlo.constant dense<1> : tensor - %extracted_4 = tensor.extract %c_3[] : tensor - %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit - %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %extracted_7 = tensor.extract %c[] : tensor - %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit - %extracted_8 = tensor.extract %c_3[] : tensor - %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - module @module_h { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @h(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<2> : tensor - %0 = quantum.alloc( 2) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %c_3 = stablehlo.constant dense<1> : tensor - %extracted_4 = tensor.extract %c_3[] : tensor - %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit - %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %extracted_7 = tensor.extract %c[] : tensor - %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit - %extracted_8 = tensor.extract %c_3[] : tensor - %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_5/1_EnforceRuntimeInvariantsPass.mlir b/global_wf_5/1_EnforceRuntimeInvariantsPass.mlir deleted file mode 100644 index 92927083a9..0000000000 --- a/global_wf_5/1_EnforceRuntimeInvariantsPass.mlir +++ /dev/null @@ -1,50 +0,0 @@ -module @global_wf { - func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.200000e+00> : tensor - %0 = call @g_0(%cst) : (tensor) -> tensor - %1 = call @h_0(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_5/2_HLOLoweringPass.mlir b/global_wf_5/2_HLOLoweringPass.mlir deleted file mode 100644 index 1ac302c438..0000000000 --- a/global_wf_5/2_HLOLoweringPass.mlir +++ /dev/null @@ -1,50 +0,0 @@ -module @global_wf { - func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.200000e+00> : tensor - %0 = call @g_0(%cst) : (tensor) -> tensor - %1 = call @h_0(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_5/3_QuantumCompilationPass.mlir b/global_wf_5/3_QuantumCompilationPass.mlir deleted file mode 100644 index 1ac302c438..0000000000 --- a/global_wf_5/3_QuantumCompilationPass.mlir +++ /dev/null @@ -1,50 +0,0 @@ -module @global_wf { - func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.200000e+00> : tensor - %0 = call @g_0(%cst) : (tensor) -> tensor - %1 = call @h_0(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_5/4_BufferizationPass.mlir b/global_wf_5/4_BufferizationPass.mlir deleted file mode 100644 index 91c3f98f74..0000000000 --- a/global_wf_5/4_BufferizationPass.mlir +++ /dev/null @@ -1,76 +0,0 @@ -module @global_wf { - memref.global "private" constant @__constant_xf64 : memref = dense<1.200000e+00> {alignment = 64 : i64} - func.func public @jit_global_wf() -> (memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(3735928559 : index) : i64 - %1 = memref.get_global @__constant_xf64 : memref - %2 = call @g_0(%1) : (memref) -> memref - %3 = call @h_0(%1) : (memref) -> memref - %4 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> - %5 = llvm.extractvalue %4[0] : !llvm.struct<(ptr, ptr, i64)> - %6 = llvm.ptrtoint %5 : !llvm.ptr to i64 - %7 = llvm.icmp "eq" %0, %6 : i64 - %8 = scf.if %7 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %2, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %2 : memref - } - %9 = builtin.unrealized_conversion_cast %3 : memref to !llvm.struct<(ptr, ptr, i64)> - %10 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> - %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 - %12 = llvm.icmp "eq" %0, %11 : i64 - %13 = scf.if %12 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %3, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %3 : memref - } - return %8, %13 : memref, memref - } - func.func public @g_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %5 = quantum.expval %4 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %5, %alloc[] : memref - %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit - quantum.dealloc %7 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func public @h_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %5 = quantum.expval %4 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %5, %alloc[] : memref - %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit - quantum.dealloc %7 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_5/5_MLIRToLLVMDialect.mlir b/global_wf_5/5_MLIRToLLVMDialect.mlir deleted file mode 100644 index e0522f0a2a..0000000000 --- a/global_wf_5/5_MLIRToLLVMDialect.mlir +++ /dev/null @@ -1,184 +0,0 @@ -module @global_wf { - llvm.func @__catalyst__rt__finalize() - llvm.func @__catalyst__rt__initialize(!llvm.ptr) - llvm.func @__catalyst__rt__device_release() - llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) - llvm.func @__catalyst__qis__Expval(i64) -> f64 - llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 - llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr - llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr - llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} - llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) - llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr - llvm.mlir.global private constant @__constant_xf64(1.200000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 - llvm.func @jit_global_wf() -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %1 = llvm.mlir.constant(0 : index) : i64 - %2 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %3 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr - %4 = llvm.mlir.constant(3735928559 : index) : i64 - %5 = llvm.mlir.constant(1 : index) : i64 - %6 = llvm.mlir.zero : !llvm.ptr - %7 = llvm.inttoptr %4 : i64 to !llvm.ptr - %8 = llvm.call @g_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %9 = llvm.call @h_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %10 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> - %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 - %12 = llvm.icmp "eq" %4, %11 : i64 - llvm.cond_br %12, ^bb1, ^bb2 - ^bb1: // pred: ^bb0 - %13 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %14 = llvm.ptrtoint %13 : !llvm.ptr to i64 - %15 = llvm.call @_mlir_memref_to_llvm_alloc(%14) : (i64) -> !llvm.ptr - %16 = llvm.insertvalue %15, %2[0] : !llvm.struct<(ptr, ptr, i64)> - %17 = llvm.insertvalue %15, %16[1] : !llvm.struct<(ptr, ptr, i64)> - %18 = llvm.insertvalue %1, %17[2] : !llvm.struct<(ptr, ptr, i64)> - %19 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %20 = llvm.ptrtoint %19 : !llvm.ptr to i64 - %21 = llvm.mul %20, %5 : i64 - %22 = llvm.extractvalue %8[1] : !llvm.struct<(ptr, ptr, i64)> - %23 = llvm.extractvalue %8[2] : !llvm.struct<(ptr, ptr, i64)> - %24 = llvm.getelementptr inbounds %22[%23] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%15, %24, %21) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb3(%18 : !llvm.struct<(ptr, ptr, i64)>) - ^bb2: // pred: ^bb0 - llvm.br ^bb3(%8 : !llvm.struct<(ptr, ptr, i64)>) - ^bb3(%25: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 - llvm.br ^bb4 - ^bb4: // pred: ^bb3 - %26 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> - %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 - %28 = llvm.icmp "eq" %4, %27 : i64 - llvm.cond_br %28, ^bb5, ^bb6 - ^bb5: // pred: ^bb4 - %29 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %30 = llvm.ptrtoint %29 : !llvm.ptr to i64 - %31 = llvm.call @_mlir_memref_to_llvm_alloc(%30) : (i64) -> !llvm.ptr - %32 = llvm.insertvalue %31, %2[0] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %1, %33[2] : !llvm.struct<(ptr, ptr, i64)> - %35 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %36 = llvm.ptrtoint %35 : !llvm.ptr to i64 - %37 = llvm.mul %36, %5 : i64 - %38 = llvm.extractvalue %9[1] : !llvm.struct<(ptr, ptr, i64)> - %39 = llvm.extractvalue %9[2] : !llvm.struct<(ptr, ptr, i64)> - %40 = llvm.getelementptr inbounds %38[%39] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%31, %40, %37) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb7(%34 : !llvm.struct<(ptr, ptr, i64)>) - ^bb6: // pred: ^bb4 - llvm.br ^bb7(%9 : !llvm.struct<(ptr, ptr, i64)>) - ^bb7(%41: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 - llvm.br ^bb8 - ^bb8: // pred: ^bb7 - %42 = llvm.insertvalue %25, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %43 = llvm.insertvalue %41, %42[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.return %43 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - } - llvm.func @_catalyst_pyface_jit_global_wf(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { - llvm.call @_catalyst_ciface_jit_global_wf(%arg0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @_catalyst_ciface_jit_global_wf(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.call @jit_global_wf() : () -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.store %0, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr - llvm.return - } - llvm.func internal @g_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(1 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(2 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr - %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 - %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 - %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 - %24 = llvm.add %23, %1 : i64 - %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr - %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 - %27 = llvm.sub %1, %2 : i64 - %28 = llvm.add %26, %27 : i64 - %29 = llvm.urem %28, %1 : i64 - %30 = llvm.sub %28, %29 : i64 - %31 = llvm.inttoptr %30 : i64 to !llvm.ptr - %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %21, %31 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func internal @h_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(1 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(2 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr - %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 - %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 - %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 - %24 = llvm.add %23, %1 : i64 - %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr - %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 - %27 = llvm.sub %1, %2 : i64 - %28 = llvm.add %26, %27 : i64 - %29 = llvm.urem %28, %1 : i64 - %30 = llvm.sub %28, %29 : i64 - %31 = llvm.inttoptr %30 : i64 to !llvm.ptr - %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %21, %31 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @setup() { - %0 = llvm.mlir.zero : !llvm.ptr - llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @teardown() { - llvm.call @__catalyst__rt__finalize() : () -> () - llvm.return - } -} \ No newline at end of file diff --git a/global_wf_5/6_llvm_ir.ll b/global_wf_5/6_llvm_ir.ll deleted file mode 100644 index b4b575588a..0000000000 --- a/global_wf_5/6_llvm_ir.ll +++ /dev/null @@ -1,165 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" - -@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" -@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" -@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" -@__constant_xf64 = private constant double 1.200000e+00, align 64 - -declare void @__catalyst__rt__finalize() - -declare void @__catalyst__rt__initialize(ptr) - -declare void @__catalyst__rt__device_release() - -declare void @__catalyst__rt__qubit_release_array(ptr) - -declare double @__catalyst__qis__Expval(i64) - -declare i64 @__catalyst__qis__NamedObs(i64, ptr) - -declare void @__catalyst__qis__RX(double, ptr, ptr) - -declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) - -declare ptr @__catalyst__rt__qubit_allocate_array(i64) - -declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) - -declare ptr @_mlir_memref_to_llvm_alloc(i64) - -define { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_global_wf() { - %1 = call { ptr, ptr, i64 } @g_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) - %2 = call { ptr, ptr, i64 } @h_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) - %3 = extractvalue { ptr, ptr, i64 } %1, 0 - %4 = ptrtoint ptr %3 to i64 - %5 = icmp eq i64 3735928559, %4 - br i1 %5, label %6, label %14 - -6: ; preds = %0 - %7 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %8 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 - %9 = insertvalue { ptr, ptr, i64 } %8, ptr %7, 1 - %10 = insertvalue { ptr, ptr, i64 } %9, i64 0, 2 - %11 = extractvalue { ptr, ptr, i64 } %1, 1 - %12 = extractvalue { ptr, ptr, i64 } %1, 2 - %13 = getelementptr inbounds double, ptr %11, i64 %12 - call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %13, i64 8, i1 false) - br label %15 - -14: ; preds = %0 - br label %15 - -15: ; preds = %6, %14 - %16 = phi { ptr, ptr, i64 } [ %1, %14 ], [ %10, %6 ] - br label %17 - -17: ; preds = %15 - %18 = extractvalue { ptr, ptr, i64 } %2, 0 - %19 = ptrtoint ptr %18 to i64 - %20 = icmp eq i64 3735928559, %19 - br i1 %20, label %21, label %29 - -21: ; preds = %17 - %22 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %23 = insertvalue { ptr, ptr, i64 } poison, ptr %22, 0 - %24 = insertvalue { ptr, ptr, i64 } %23, ptr %22, 1 - %25 = insertvalue { ptr, ptr, i64 } %24, i64 0, 2 - %26 = extractvalue { ptr, ptr, i64 } %2, 1 - %27 = extractvalue { ptr, ptr, i64 } %2, 2 - %28 = getelementptr inbounds double, ptr %26, i64 %27 - call void @llvm.memcpy.p0.p0.i64(ptr %22, ptr %28, i64 8, i1 false) - br label %30 - -29: ; preds = %17 - br label %30 - -30: ; preds = %21, %29 - %31 = phi { ptr, ptr, i64 } [ %2, %29 ], [ %25, %21 ] - br label %32 - -32: ; preds = %30 - %33 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %16, 0 - %34 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %33, { ptr, ptr, i64 } %31, 1 - ret { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %34 -} - -define void @_catalyst_pyface_jit_global_wf(ptr %0, ptr %1) { - call void @_catalyst_ciface_jit_global_wf(ptr %0) - ret void -} - -define void @_catalyst_ciface_jit_global_wf(ptr %0) { - %2 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_global_wf() - store { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %2, ptr %0, align 8 - ret void -} - -define internal { ptr, ptr, i64 } @g_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) - %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) - %10 = call double @__catalyst__qis__Expval(i64 %9) - %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %12 = ptrtoint ptr %11 to i64 - %13 = add i64 %12, 63 - %14 = urem i64 %13, 64 - %15 = sub i64 %13, %14 - %16 = inttoptr i64 %15 to ptr - %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 - %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 - %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 - store double %10, ptr %16, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %19 -} - -define internal { ptr, ptr, i64 } @h_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) - %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) - %10 = call double @__catalyst__qis__Expval(i64 %9) - %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %12 = ptrtoint ptr %11 to i64 - %13 = add i64 %12, 63 - %14 = urem i64 %13, 64 - %15 = sub i64 %13, %14 - %16 = inttoptr i64 %15 to ptr - %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 - %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 - %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 - store double %10, ptr %16, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %19 -} - -define void @setup() { - call void @__catalyst__rt__initialize(ptr null) - ret void -} - -define void @teardown() { - call void @__catalyst__rt__finalize() - ret void -} - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 - -attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/global_wf_5/global_wf.o b/global_wf_5/global_wf.o deleted file mode 100644 index 045e0e00841ab881f1401f526433e3cc32bf59f0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3848 zcmds4U2GIp6h6}}u;ph9QbdH%HJY>mmIX>gg$=9xnlwlN6CQ}S)9th!n4Mi_r=?3Z zZUQDIn%Ei>eL%C1l=$F-4;n~Z-*^L!5FRj@EhSm}NsRiyn5^|XGk4nEwu{jh6HjvI zn{&SNcki8@JA31gpZ{D=q!5HJ%^2Y(T%s6|br^4Ztf$Vq6c_uZPL6>D`V!pp;Cw7X z*xHEg-~0NB11C?+>cQQmkblSdIOX*)(H1r}Q-L86AyOGLH=9t1`g|psCoFrfEFzMv z1}W;0^QE(D$`(WBIo<3NqI-X>!*w|kM;d=YGA_}%)SoAA2p)J&v&+aqWnEn%oC_QDdfumiav#0>AGO zJ+va%YUElgdw_o#{*%Z%S;Kifw1Qg=`&x_;;+7z88M*gENq1^V(!I9~_Vw^-PolS^ zTOECQ0_#3r3W?j*(XS?WO{$|`UuJ#!0%1Rt2?sgYUP1h#HRLw0A~&>x+@= zU%_5s4qi?#4r^D&8cm{Rb#(s(=JUUv7w=X;Qm%dJJP9is^f*|LDk4< zTcRE2P+Ig3S*C8nxDAFgnq_K+F!9QQv{R`J62@b2x73z42_`9?Y0sTet6s=X6_(;f;Gn9nf;| ztY(^dLp3#F1eG{oMiFO+dUaa_3Ags;!Pd9%NUh70-}VMh1w8Z+c}fIUB59|UzG)sm z=Eu=<4fyMlztey(;z!2Ph#!#^+kCfq_1~42M*T@UDd&%oGO|%wxxAgC$i-*G)U+?b z9O-bRsC=S)%q?xe*n?4$K0zMZA6dyR%%8$2N?y*NkRuxKuY)g0Ue1sCqXB;je9t5J zYv7ZTm-DCE`gg%cB|o>nF|5lPqF4d=IPeq@IbtV)n0ss|a2@a&AkM&86o?$LHsE8x zX5cE|Pgo4r9pGBvP2g%^35X-V`x}DaUvp;nKa+$HWF8O2^Q z7NU)e_^yeRq|UekdQs|(=qFN;IwSgs^hli%^N1v+&WP`r2=~kR88P3;TO5SKfvBuw zl;ro@nB;@s={r&{0$FY$mi?pB|0-;(^Ww5_YA+v}WqFh1F-lU;vyS`Vdojm4VuSC! zbx6>P5xhrS&A*+WcS6@h9=`P9lL1^x!ZNmM!FYpc+O7c1@_3rRMQ3V?i%V zGc+~V(5X)w)>E3$P2H}~a8}O=aRdiq-z&X25(}JxBB$9yS;C(i)#}TfGZ%6k>Yc`UHeh6WRYRQXujNzvg8Xa(Zvpyo${PB4t-d5L4NpXGz{$DF6`3FF zt)m#waAX@=S~G2twJou|51wg5w?tY?TUx)cGr};2)52SS693KVU$@)dUL8A023z^B gp^Dx|`k&oNhMmrKdDk7@b-Q=nMq*IlGJp%@FYN<(vH$=8 diff --git a/global_wf_6/0_global_wf.mlir b/global_wf_6/0_global_wf.mlir deleted file mode 100644 index cc7499d896..0000000000 --- a/global_wf_6/0_global_wf.mlir +++ /dev/null @@ -1,85 +0,0 @@ -module @global_wf { - func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.200000e+00> : tensor - %0 = catalyst.launch_kernel @module_g::@g(%cst) : (tensor) -> tensor - %1 = catalyst.launch_kernel @module_h::@h(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - module @module_g { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @g(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<2> : tensor - %0 = quantum.alloc( 2) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %c_3 = stablehlo.constant dense<1> : tensor - %extracted_4 = tensor.extract %c_3[] : tensor - %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit - %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %extracted_7 = tensor.extract %c[] : tensor - %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit - %extracted_8 = tensor.extract %c_3[] : tensor - %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - module @module_h { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "merge-rotations" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @h(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<2> : tensor - %0 = quantum.alloc( 2) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %c_3 = stablehlo.constant dense<1> : tensor - %extracted_4 = tensor.extract %c_3[] : tensor - %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit - %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %extracted_7 = tensor.extract %c[] : tensor - %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit - %extracted_8 = tensor.extract %c_3[] : tensor - %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_6/1_EnforceRuntimeInvariantsPass.mlir b/global_wf_6/1_EnforceRuntimeInvariantsPass.mlir deleted file mode 100644 index d29883c8f0..0000000000 --- a/global_wf_6/1_EnforceRuntimeInvariantsPass.mlir +++ /dev/null @@ -1,52 +0,0 @@ -module @global_wf { - func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.200000e+00> : tensor - %0 = call @g_0(%cst) : (tensor) -> tensor - %1 = call @h_0(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_6/2_HLOLoweringPass.mlir b/global_wf_6/2_HLOLoweringPass.mlir deleted file mode 100644 index 173b7cb80d..0000000000 --- a/global_wf_6/2_HLOLoweringPass.mlir +++ /dev/null @@ -1,52 +0,0 @@ -module @global_wf { - func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.200000e+00> : tensor - %0 = call @g_0(%cst) : (tensor) -> tensor - %1 = call @h_0(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_6/3_QuantumCompilationPass.mlir b/global_wf_6/3_QuantumCompilationPass.mlir deleted file mode 100644 index 173b7cb80d..0000000000 --- a/global_wf_6/3_QuantumCompilationPass.mlir +++ /dev/null @@ -1,52 +0,0 @@ -module @global_wf { - func.func public @jit_global_wf() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.200000e+00> : tensor - %0 = call @g_0(%cst) : (tensor) -> tensor - %1 = call @h_0(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_6/4_BufferizationPass.mlir b/global_wf_6/4_BufferizationPass.mlir deleted file mode 100644 index 3dcf4bb651..0000000000 --- a/global_wf_6/4_BufferizationPass.mlir +++ /dev/null @@ -1,78 +0,0 @@ -module @global_wf { - memref.global "private" constant @__constant_xf64 : memref = dense<1.200000e+00> {alignment = 64 : i64} - func.func public @jit_global_wf() -> (memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(3735928559 : index) : i64 - %1 = memref.get_global @__constant_xf64 : memref - %2 = call @g_0(%1) : (memref) -> memref - %3 = call @h_0(%1) : (memref) -> memref - %4 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> - %5 = llvm.extractvalue %4[0] : !llvm.struct<(ptr, ptr, i64)> - %6 = llvm.ptrtoint %5 : !llvm.ptr to i64 - %7 = llvm.icmp "eq" %0, %6 : i64 - %8 = scf.if %7 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %2, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %2 : memref - } - %9 = builtin.unrealized_conversion_cast %3 : memref to !llvm.struct<(ptr, ptr, i64)> - %10 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> - %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 - %12 = llvm.icmp "eq" %0, %11 : i64 - %13 = scf.if %12 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %3, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %3 : memref - } - return %8, %13 : memref, memref - } - func.func public @g_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %5 = quantum.expval %4 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %5, %alloc[] : memref - %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit - quantum.dealloc %7 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func public @h_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %3 : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %5 = quantum.expval %4 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %5, %alloc[] : memref - %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %7 = quantum.insert %6[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %7 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/global_wf_6/5_MLIRToLLVMDialect.mlir b/global_wf_6/5_MLIRToLLVMDialect.mlir deleted file mode 100644 index 5d5a0e433c..0000000000 --- a/global_wf_6/5_MLIRToLLVMDialect.mlir +++ /dev/null @@ -1,188 +0,0 @@ -module @global_wf { - llvm.func @__catalyst__rt__finalize() - llvm.func @__catalyst__rt__initialize(!llvm.ptr) - llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__device_release() - llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) - llvm.func @__catalyst__qis__Expval(i64) -> f64 - llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 - llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr - llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr - llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} - llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) - llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr - llvm.mlir.global private constant @__constant_xf64(1.200000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 - llvm.func @jit_global_wf() -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %1 = llvm.mlir.constant(0 : index) : i64 - %2 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %3 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr - %4 = llvm.mlir.constant(3735928559 : index) : i64 - %5 = llvm.mlir.constant(1 : index) : i64 - %6 = llvm.mlir.zero : !llvm.ptr - %7 = llvm.inttoptr %4 : i64 to !llvm.ptr - %8 = llvm.call @g_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %9 = llvm.call @h_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %10 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> - %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 - %12 = llvm.icmp "eq" %4, %11 : i64 - llvm.cond_br %12, ^bb1, ^bb2 - ^bb1: // pred: ^bb0 - %13 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %14 = llvm.ptrtoint %13 : !llvm.ptr to i64 - %15 = llvm.call @_mlir_memref_to_llvm_alloc(%14) : (i64) -> !llvm.ptr - %16 = llvm.insertvalue %15, %2[0] : !llvm.struct<(ptr, ptr, i64)> - %17 = llvm.insertvalue %15, %16[1] : !llvm.struct<(ptr, ptr, i64)> - %18 = llvm.insertvalue %1, %17[2] : !llvm.struct<(ptr, ptr, i64)> - %19 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %20 = llvm.ptrtoint %19 : !llvm.ptr to i64 - %21 = llvm.mul %20, %5 : i64 - %22 = llvm.extractvalue %8[1] : !llvm.struct<(ptr, ptr, i64)> - %23 = llvm.extractvalue %8[2] : !llvm.struct<(ptr, ptr, i64)> - %24 = llvm.getelementptr inbounds %22[%23] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%15, %24, %21) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb3(%18 : !llvm.struct<(ptr, ptr, i64)>) - ^bb2: // pred: ^bb0 - llvm.br ^bb3(%8 : !llvm.struct<(ptr, ptr, i64)>) - ^bb3(%25: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 - llvm.br ^bb4 - ^bb4: // pred: ^bb3 - %26 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> - %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 - %28 = llvm.icmp "eq" %4, %27 : i64 - llvm.cond_br %28, ^bb5, ^bb6 - ^bb5: // pred: ^bb4 - %29 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %30 = llvm.ptrtoint %29 : !llvm.ptr to i64 - %31 = llvm.call @_mlir_memref_to_llvm_alloc(%30) : (i64) -> !llvm.ptr - %32 = llvm.insertvalue %31, %2[0] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %1, %33[2] : !llvm.struct<(ptr, ptr, i64)> - %35 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %36 = llvm.ptrtoint %35 : !llvm.ptr to i64 - %37 = llvm.mul %36, %5 : i64 - %38 = llvm.extractvalue %9[1] : !llvm.struct<(ptr, ptr, i64)> - %39 = llvm.extractvalue %9[2] : !llvm.struct<(ptr, ptr, i64)> - %40 = llvm.getelementptr inbounds %38[%39] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%31, %40, %37) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb7(%34 : !llvm.struct<(ptr, ptr, i64)>) - ^bb6: // pred: ^bb4 - llvm.br ^bb7(%9 : !llvm.struct<(ptr, ptr, i64)>) - ^bb7(%41: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 - llvm.br ^bb8 - ^bb8: // pred: ^bb7 - %42 = llvm.insertvalue %25, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %43 = llvm.insertvalue %41, %42[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.return %43 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - } - llvm.func @_catalyst_pyface_jit_global_wf(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { - llvm.call @_catalyst_ciface_jit_global_wf(%arg0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @_catalyst_ciface_jit_global_wf(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.call @jit_global_wf() : () -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.store %0, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr - llvm.return - } - llvm.func internal @g_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(1 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(2 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr - %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 - %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 - %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 - %24 = llvm.add %23, %1 : i64 - %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr - %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 - %27 = llvm.sub %1, %2 : i64 - %28 = llvm.add %26, %27 : i64 - %29 = llvm.urem %28, %1 : i64 - %30 = llvm.sub %28, %29 : i64 - %31 = llvm.inttoptr %30 : i64 to !llvm.ptr - %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %21, %31 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func internal @h_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(1 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(2 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr - %20 = llvm.load %19 : !llvm.ptr -> !llvm.ptr - llvm.call @__catalyst__qis__Hadamard(%20, %4) : (!llvm.ptr, !llvm.ptr) -> () - llvm.call @__catalyst__qis__Hadamard(%20, %4) : (!llvm.ptr, !llvm.ptr) -> () - %21 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 - %22 = llvm.call @__catalyst__qis__Expval(%21) : (i64) -> f64 - %23 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %24 = llvm.ptrtoint %23 : !llvm.ptr to i64 - %25 = llvm.add %24, %1 : i64 - %26 = llvm.call @_mlir_memref_to_llvm_alloc(%25) : (i64) -> !llvm.ptr - %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 - %28 = llvm.sub %1, %2 : i64 - %29 = llvm.add %27, %28 : i64 - %30 = llvm.urem %29, %1 : i64 - %31 = llvm.sub %29, %30 : i64 - %32 = llvm.inttoptr %31 : i64 to !llvm.ptr - %33 = llvm.insertvalue %26, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %32, %33[1] : !llvm.struct<(ptr, ptr, i64)> - %35 = llvm.insertvalue %0, %34[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %22, %32 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %35 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @setup() { - %0 = llvm.mlir.zero : !llvm.ptr - llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @teardown() { - llvm.call @__catalyst__rt__finalize() : () -> () - llvm.return - } -} \ No newline at end of file diff --git a/global_wf_6/6_llvm_ir.ll b/global_wf_6/6_llvm_ir.ll deleted file mode 100644 index 11cb9eb439..0000000000 --- a/global_wf_6/6_llvm_ir.ll +++ /dev/null @@ -1,170 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" - -@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" -@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" -@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" -@__constant_xf64 = private constant double 1.200000e+00, align 64 - -declare void @__catalyst__rt__finalize() - -declare void @__catalyst__rt__initialize(ptr) - -declare void @__catalyst__qis__Hadamard(ptr, ptr) - -declare void @__catalyst__rt__device_release() - -declare void @__catalyst__rt__qubit_release_array(ptr) - -declare double @__catalyst__qis__Expval(i64) - -declare i64 @__catalyst__qis__NamedObs(i64, ptr) - -declare void @__catalyst__qis__RX(double, ptr, ptr) - -declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) - -declare ptr @__catalyst__rt__qubit_allocate_array(i64) - -declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) - -declare ptr @_mlir_memref_to_llvm_alloc(i64) - -define { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_global_wf() { - %1 = call { ptr, ptr, i64 } @g_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) - %2 = call { ptr, ptr, i64 } @h_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) - %3 = extractvalue { ptr, ptr, i64 } %1, 0 - %4 = ptrtoint ptr %3 to i64 - %5 = icmp eq i64 3735928559, %4 - br i1 %5, label %6, label %14 - -6: ; preds = %0 - %7 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %8 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 - %9 = insertvalue { ptr, ptr, i64 } %8, ptr %7, 1 - %10 = insertvalue { ptr, ptr, i64 } %9, i64 0, 2 - %11 = extractvalue { ptr, ptr, i64 } %1, 1 - %12 = extractvalue { ptr, ptr, i64 } %1, 2 - %13 = getelementptr inbounds double, ptr %11, i64 %12 - call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %13, i64 8, i1 false) - br label %15 - -14: ; preds = %0 - br label %15 - -15: ; preds = %6, %14 - %16 = phi { ptr, ptr, i64 } [ %1, %14 ], [ %10, %6 ] - br label %17 - -17: ; preds = %15 - %18 = extractvalue { ptr, ptr, i64 } %2, 0 - %19 = ptrtoint ptr %18 to i64 - %20 = icmp eq i64 3735928559, %19 - br i1 %20, label %21, label %29 - -21: ; preds = %17 - %22 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %23 = insertvalue { ptr, ptr, i64 } poison, ptr %22, 0 - %24 = insertvalue { ptr, ptr, i64 } %23, ptr %22, 1 - %25 = insertvalue { ptr, ptr, i64 } %24, i64 0, 2 - %26 = extractvalue { ptr, ptr, i64 } %2, 1 - %27 = extractvalue { ptr, ptr, i64 } %2, 2 - %28 = getelementptr inbounds double, ptr %26, i64 %27 - call void @llvm.memcpy.p0.p0.i64(ptr %22, ptr %28, i64 8, i1 false) - br label %30 - -29: ; preds = %17 - br label %30 - -30: ; preds = %21, %29 - %31 = phi { ptr, ptr, i64 } [ %2, %29 ], [ %25, %21 ] - br label %32 - -32: ; preds = %30 - %33 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %16, 0 - %34 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %33, { ptr, ptr, i64 } %31, 1 - ret { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %34 -} - -define void @_catalyst_pyface_jit_global_wf(ptr %0, ptr %1) { - call void @_catalyst_ciface_jit_global_wf(ptr %0) - ret void -} - -define void @_catalyst_ciface_jit_global_wf(ptr %0) { - %2 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_global_wf() - store { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %2, ptr %0, align 8 - ret void -} - -define internal { ptr, ptr, i64 } @g_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) - %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) - %10 = call double @__catalyst__qis__Expval(i64 %9) - %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %12 = ptrtoint ptr %11 to i64 - %13 = add i64 %12, 63 - %14 = urem i64 %13, 64 - %15 = sub i64 %13, %14 - %16 = inttoptr i64 %15 to ptr - %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 - %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 - %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 - store double %10, ptr %16, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %19 -} - -define internal { ptr, ptr, i64 } @h_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) - %9 = load ptr, ptr %8, align 8 - call void @__catalyst__qis__Hadamard(ptr %9, ptr null) - call void @__catalyst__qis__Hadamard(ptr %9, ptr null) - %10 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) - %11 = call double @__catalyst__qis__Expval(i64 %10) - %12 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %13 = ptrtoint ptr %12 to i64 - %14 = add i64 %13, 63 - %15 = urem i64 %14, 64 - %16 = sub i64 %14, %15 - %17 = inttoptr i64 %16 to ptr - %18 = insertvalue { ptr, ptr, i64 } poison, ptr %12, 0 - %19 = insertvalue { ptr, ptr, i64 } %18, ptr %17, 1 - %20 = insertvalue { ptr, ptr, i64 } %19, i64 0, 2 - store double %11, ptr %17, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %20 -} - -define void @setup() { - call void @__catalyst__rt__initialize(ptr null) - ret void -} - -define void @teardown() { - call void @__catalyst__rt__finalize() - ret void -} - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 - -attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/global_wf_6/global_wf.o b/global_wf_6/global_wf.o deleted file mode 100644 index 66050ae0428ca9794b9dee52ba519d778d49a7aa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3904 zcmc&%Uu;uV82|3NLC2pCWH=GRYBU)EN`VnUp`i-MOcq=K6CQ|Xcimlg;r6z)cVlCi zG#L**>1Iew44OWfZSvrQ4%J-)o2z!r(_EroRD?AST8p%nuya5tlr2E8L}RY=hy+EAh^g{qYdO z(nc)z-IY%tJ9BzL_TFyz+&A{eE^qsZcJWdpWf{C7L@a4$790vu>n|_;_+{>;CL)=t z=b{GLUm~T(EHPwW)Xjb&x{p>X+?Ivda`6eAafkz}+&b|pJK!n^p$&?Gw3^U7xi-Hk z6Y{2JjFqI-G<#}-~=}FD=fmEdN6r_awdmt z!Gy}c9&_Uj-&Mw%r|q9U`9AmK&EK&t6N*BUMPK_2oL#jKQn}Dc<>G!S*V8HaXvRJm zEtd{M_Xu>4Q@I3xQ}EZW&@V~@o%So)leW*loqhhiAG)2<@?*9`oPw`;rikeuJ@<5* z0{ag5*@1XrDkGm(8~O$47ZIbHL(f|64sbiL9>&}ZyLQ;UOy$Ri5o11w=A}6t2Y=)l zIkdpn2KZ`|IY7Sv{UZDpt2ifz7H}J|-iGOe-AdT4rt%|Sv^={qT7I}1>zkp|9z|}^ za%Jr8Y4m+E?-TbbW8X}3Pby>IPO&^UPS_7++J+BaFTuWPBb6K1Q`xtc$_>p_R+_*m z1V3-U4>^A3jwrBeoGu_f>?SZLk=w*eKpdNiH-Qh)>xbyitgqeKhc0sWgmdLsPJXD_ ziHqD>CPL1fixREyx{W%w!LA_pvVi<-)W@8|w@}63ys+1HOSIyg57?Esmlc}yKf3gB z344Va9G{LIdRIV?iilYmJ35Ve+`7iOuBK`3DfH^s)v-)n*eCW~=s=Df5AWPhmYuq| zRT|4wZ?l=46i8E4LbDOLgK1=BLe9btQH8rEw0?tDbu_|N7u$OMl zd?xtsf_;1EV(~cv=ZvwAL@W{Ocs=-*YGkyX!47jMA^L{Wrfy!F{6GMh-CDTKZv~(sM8%*mNOE=YUPdXV7$5cx-Ml+Vs z%;B)1_k~lV)?m`?+_h(KIHOxy2*0@J)wq@kr!>`S@;BFv%g5%?VNS2TxZ8;Bl; z?gEipC=bLZK=&;dBR7D!U%S6{F~WB+J{h{NyBN6w_Th*17NCBY78BUqRLeQ6Rm*YYQ!URd(jQ->pIpShwn#p; zNS5abUfl5>04no?&u6tv;=kQg0w3_+Wh2s-koSdZ7)h*aLQSXDQT!LOtX5hxG&NIK zsb3q`W17%S-KzC)LC*+r0vBfgJAD}v%iNJ7qgg{K!aqN1x<7f*T*m&`NNQL$K+NZ# z8XZs(?;P&CxRLBr4RLXxnvdzr@(T`}1`Oa9HuOtcZAfkn7oykUWUaCzwYE;VU24CY zKryuxyLDPD;u>yyLrZ9;B~n&e>|xD>p{GScOQf{{VI_rO3@3!MH6;F@4~LqA;M8^U l3>m!2|5d8UePrO(ePmdPRHyUY>pb^3&)p;j1s-uc{sDLEle7Q; diff --git a/test_cancel_inverses_keep_original_workflow0_2/0_test_cancel_inverses_keep_original_workflow0.mlir b/test_cancel_inverses_keep_original_workflow0_2/0_test_cancel_inverses_keep_original_workflow0.mlir deleted file mode 100644 index aa764eebbe..0000000000 --- a/test_cancel_inverses_keep_original_workflow0_2/0_test_cancel_inverses_keep_original_workflow0.mlir +++ /dev/null @@ -1,43 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow0 { - func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> tensor attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.000000e+00> : tensor - %0 = catalyst.launch_kernel @module_f::@f(%cst) : (tensor) -> tensor - return %0 : tensor - } - module @module_f { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - transform.yield - } - } - func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<1> : tensor - %0 = quantum.alloc( 1) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit - %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %extracted_5 = tensor.extract %c[] : tensor - %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/1_EnforceRuntimeInvariantsPass.mlir b/test_cancel_inverses_keep_original_workflow0_2/1_EnforceRuntimeInvariantsPass.mlir deleted file mode 100644 index 4fb48f93b0..0000000000 --- a/test_cancel_inverses_keep_original_workflow0_2/1_EnforceRuntimeInvariantsPass.mlir +++ /dev/null @@ -1,32 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow0 { - func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> tensor attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.000000e+00> : tensor - %0 = call @f_0(%cst) : (tensor) -> tensor - return %0 : tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/2_HLOLoweringPass.mlir b/test_cancel_inverses_keep_original_workflow0_2/2_HLOLoweringPass.mlir deleted file mode 100644 index b3a9f0361a..0000000000 --- a/test_cancel_inverses_keep_original_workflow0_2/2_HLOLoweringPass.mlir +++ /dev/null @@ -1,32 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow0 { - func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> tensor attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.000000e+00> : tensor - %0 = call @f_0(%cst) : (tensor) -> tensor - return %0 : tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/3_QuantumCompilationPass.mlir b/test_cancel_inverses_keep_original_workflow0_2/3_QuantumCompilationPass.mlir deleted file mode 100644 index b3a9f0361a..0000000000 --- a/test_cancel_inverses_keep_original_workflow0_2/3_QuantumCompilationPass.mlir +++ /dev/null @@ -1,32 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow0 { - func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> tensor attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.000000e+00> : tensor - %0 = call @f_0(%cst) : (tensor) -> tensor - return %0 : tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/4_BufferizationPass.mlir b/test_cancel_inverses_keep_original_workflow0_2/4_BufferizationPass.mlir deleted file mode 100644 index 2b591faa52..0000000000 --- a/test_cancel_inverses_keep_original_workflow0_2/4_BufferizationPass.mlir +++ /dev/null @@ -1,46 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow0 { - memref.global "private" constant @__constant_xf64 : memref = dense<1.000000e+00> {alignment = 64 : i64} - func.func public @jit_test_cancel_inverses_keep_original_workflow0() -> memref attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(3735928559 : index) : i64 - %1 = memref.get_global @__constant_xf64 : memref - %2 = call @f_0(%1) : (memref) -> memref - %3 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> - %4 = llvm.extractvalue %3[0] : !llvm.struct<(ptr, ptr, i64)> - %5 = llvm.ptrtoint %4 : !llvm.ptr to i64 - %6 = llvm.icmp "eq" %0, %5 : i64 - %7 = scf.if %6 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %2, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %2 : memref - } - return %7 : memref - } - func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %4 = quantum.expval %3 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %4, %alloc[] : memref - %5 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %5 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/5_MLIRToLLVMDialect.mlir b/test_cancel_inverses_keep_original_workflow0_2/5_MLIRToLLVMDialect.mlir deleted file mode 100644 index 9e1d6c4310..0000000000 --- a/test_cancel_inverses_keep_original_workflow0_2/5_MLIRToLLVMDialect.mlir +++ /dev/null @@ -1,115 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow0 { - llvm.func @__catalyst__rt__finalize() - llvm.func @__catalyst__rt__initialize(!llvm.ptr) - llvm.func @__catalyst__rt__device_release() - llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) - llvm.func @__catalyst__qis__Expval(i64) -> f64 - llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 - llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr - llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr - llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} - llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) - llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr - llvm.mlir.global private constant @__constant_xf64(1.000000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 - llvm.func @jit_test_cancel_inverses_keep_original_workflow0() -> !llvm.struct<(ptr, ptr, i64)> attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %2 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr - %3 = llvm.mlir.constant(3735928559 : index) : i64 - %4 = llvm.mlir.constant(1 : index) : i64 - %5 = llvm.mlir.zero : !llvm.ptr - %6 = llvm.inttoptr %3 : i64 to !llvm.ptr - %7 = llvm.call @f_0(%6, %2, %0) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %8 = llvm.extractvalue %7[0] : !llvm.struct<(ptr, ptr, i64)> - %9 = llvm.ptrtoint %8 : !llvm.ptr to i64 - %10 = llvm.icmp "eq" %3, %9 : i64 - llvm.cond_br %10, ^bb1, ^bb2 - ^bb1: // pred: ^bb0 - %11 = llvm.getelementptr %5[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %12 = llvm.ptrtoint %11 : !llvm.ptr to i64 - %13 = llvm.call @_mlir_memref_to_llvm_alloc(%12) : (i64) -> !llvm.ptr - %14 = llvm.insertvalue %13, %1[0] : !llvm.struct<(ptr, ptr, i64)> - %15 = llvm.insertvalue %13, %14[1] : !llvm.struct<(ptr, ptr, i64)> - %16 = llvm.insertvalue %0, %15[2] : !llvm.struct<(ptr, ptr, i64)> - %17 = llvm.getelementptr %5[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %18 = llvm.ptrtoint %17 : !llvm.ptr to i64 - %19 = llvm.mul %18, %4 : i64 - %20 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64)> - %21 = llvm.extractvalue %7[2] : !llvm.struct<(ptr, ptr, i64)> - %22 = llvm.getelementptr inbounds %20[%21] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%13, %22, %19) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb3(%16 : !llvm.struct<(ptr, ptr, i64)>) - ^bb2: // pred: ^bb0 - llvm.br ^bb3(%7 : !llvm.struct<(ptr, ptr, i64)>) - ^bb3(%23: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 - llvm.br ^bb4 - ^bb4: // pred: ^bb3 - llvm.return %23 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow0(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { - llvm.call @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow0(%arg0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow0(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.call @jit_test_cancel_inverses_keep_original_workflow0() : () -> !llvm.struct<(ptr, ptr, i64)> - llvm.store %0, %arg0 : !llvm.struct<(ptr, ptr, i64)>, !llvm.ptr - llvm.return - } - llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(3 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(1 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () - llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 - %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 - %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 - %23 = llvm.add %22, %1 : i64 - %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr - %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 - %26 = llvm.sub %1, %2 : i64 - %27 = llvm.add %25, %26 : i64 - %28 = llvm.urem %27, %1 : i64 - %29 = llvm.sub %27, %28 : i64 - %30 = llvm.inttoptr %29 : i64 to !llvm.ptr - %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %20, %30 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @setup() { - %0 = llvm.mlir.zero : !llvm.ptr - llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @teardown() { - llvm.call @__catalyst__rt__finalize() : () -> () - llvm.return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow0_2/6_llvm_ir.ll b/test_cancel_inverses_keep_original_workflow0_2/6_llvm_ir.ll deleted file mode 100644 index 13646634c3..0000000000 --- a/test_cancel_inverses_keep_original_workflow0_2/6_llvm_ir.ll +++ /dev/null @@ -1,116 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" - -@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" -@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" -@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" -@__constant_xf64 = private constant double 1.000000e+00, align 64 - -declare void @__catalyst__rt__finalize() - -declare void @__catalyst__rt__initialize(ptr) - -declare void @__catalyst__rt__device_release() - -declare void @__catalyst__rt__qubit_release_array(ptr) - -declare double @__catalyst__qis__Expval(i64) - -declare i64 @__catalyst__qis__NamedObs(i64, ptr) - -declare void @__catalyst__qis__Hadamard(ptr, ptr) - -declare void @__catalyst__qis__RX(double, ptr, ptr) - -declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) - -declare ptr @__catalyst__rt__qubit_allocate_array(i64) - -declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) - -declare ptr @_mlir_memref_to_llvm_alloc(i64) - -define { ptr, ptr, i64 } @jit_test_cancel_inverses_keep_original_workflow0() { - %1 = call { ptr, ptr, i64 } @f_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) - %2 = extractvalue { ptr, ptr, i64 } %1, 0 - %3 = ptrtoint ptr %2 to i64 - %4 = icmp eq i64 3735928559, %3 - br i1 %4, label %5, label %13 - -5: ; preds = %0 - %6 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %7 = insertvalue { ptr, ptr, i64 } poison, ptr %6, 0 - %8 = insertvalue { ptr, ptr, i64 } %7, ptr %6, 1 - %9 = insertvalue { ptr, ptr, i64 } %8, i64 0, 2 - %10 = extractvalue { ptr, ptr, i64 } %1, 1 - %11 = extractvalue { ptr, ptr, i64 } %1, 2 - %12 = getelementptr inbounds double, ptr %10, i64 %11 - call void @llvm.memcpy.p0.p0.i64(ptr %6, ptr %12, i64 8, i1 false) - br label %14 - -13: ; preds = %0 - br label %14 - -14: ; preds = %5, %13 - %15 = phi { ptr, ptr, i64 } [ %1, %13 ], [ %9, %5 ] - br label %16 - -16: ; preds = %14 - ret { ptr, ptr, i64 } %15 -} - -define void @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow0(ptr %0, ptr %1) { - call void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow0(ptr %0) - ret void -} - -define void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow0(ptr %0) { - %2 = call { ptr, ptr, i64 } @jit_test_cancel_inverses_keep_original_workflow0() - store { ptr, ptr, i64 } %2, ptr %0, align 8 - ret void -} - -define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - call void @__catalyst__qis__Hadamard(ptr %6, ptr null) - call void @__catalyst__qis__Hadamard(ptr %6, ptr null) - %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) - %9 = call double @__catalyst__qis__Expval(i64 %8) - %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %11 = ptrtoint ptr %10 to i64 - %12 = add i64 %11, 63 - %13 = urem i64 %12, 64 - %14 = sub i64 %12, %13 - %15 = inttoptr i64 %14 to ptr - %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 - %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 - %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 - store double %9, ptr %15, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %18 -} - -define void @setup() { - call void @__catalyst__rt__initialize(ptr null) - ret void -} - -define void @teardown() { - call void @__catalyst__rt__finalize() - ret void -} - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 - -attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_cancel_inverses_keep_original_workflow0_2/test_cancel_inverses_keep_original_workflow0.o b/test_cancel_inverses_keep_original_workflow0_2/test_cancel_inverses_keep_original_workflow0.o deleted file mode 100644 index 910ae18dc939762033e8bdade9fd39e98d97f7ef..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3320 zcmc&$PiP!v6o1q0pG{jg(L`HqX;ykjk#09_MMN50HI*Df8)}3i;)^r-cO_v7C&}^;ydt2g0P+hy&Gr)_JN1b4p_(72P@+DV9%t~B!nmD zJhljz5Tj==jz-)T?o@F&9&h6a!Z{$&JVUgE$Q5mOD`0E9jEWOixfhVg?#Ou?cr4M2w4z$N4I3eH`g0ijrmT+>qn5_ zh&U162kj#&C{+Nb@H_|#%Xw;3#fP#y3%@|RmuMYA_|u58>Hsn!WlDfJ{(oH?SG2F| zm0ipJ_aA(-^zF?*aNL5X(c)UH_Xc8J^?RwddX#EweN?N$<~nS8HTp%{L8EbP{(>Ki zKf`uE_ho9;qnX-IF}mTycQw{=V+|B9Pp%)+;NOin2dL&Bq8iTV@nOFT`?X$BgARS@ z@w=fr0Qn)%9{BBpUngM?`MwPHnOePab{V-ZuEfOMdgb$F&Y@oU;yUviR|qv}%RYQr zUWMO|4ytLpz$2G>MZw>b0}}#b1j92Sb=RP)#Dvo@lk8N$~{F-s_0+5PK)s$ zF27$zA5lvXKk!4pR=Hm|zg`(!MqQh|;rGEdQGZ(d1>HlhN}rXpa(yo(U)4=l9#8h! z)0P;Uc5K6jupfdc>DbZ~Ha;0h&J}I>PQz)##zet`@x*I}HErr%(P>a(n||Guj+@RE z9K-btTThQT#ffxI_jI%DdP3SWY10@>m&#tDXrDfD@>JS2Jek55Kc!DdH(ippT{d-F z3Nt#19X1(pX?o1?L=^DEcp2K}6#fPG`-_p$t#G4ml}JjY_B zet3aUPaFN8O5g5$B`59j1=8k@XkGhzDT!Eo2i@NYS5yNHC9)rBAL8>MIt)4kT2VGp z92!h?u?_3r1T87Os*eyO8R_4KeqQN)?1MFw7>V@PAjm4cs*f7ue+GS~&H3x7`*EUF z75D`377#H~D?rqix(37?O1%ff9h%~qh#FFJz)qm4FbjMX{1EUl;2GcnU_Y=Mm;~Y; z9zGo6z(F8J!EjHA16@G;D2DfkIN&2^+~uh+fw;p{gFw#XFc6JRah)(7=6(VPmO|V; zuQ01HqcEuu!1lXWfVgLmFg}9PmK4v3IgyxGJR{CaWEIbdd=eSOGwub?d2u{OEJ{apRi23L{@xdzdts^*51bd>|AL^H=7k) zKps=WG%m{rHJpgiMyGOB6*c}Rx`kw#ReWI3A~7K`olI#-+Y=?v5hvNwG7U#q z(sE>8ctv5FGnNQiOXB|-bWJZZsO!Q-GFi(1!gb_6mw)bAGCiwwI(VK6o+nYu=Fg;5 z&g*!slNh6(#7xfVb`AsIuxBv2r7NbSEQz9HOz?{kvqfhrZx(0!8$;xbhYP`ZAy8iQ I<8uhsKgdedod5s; diff --git a/test_cancel_inverses_keep_original_workflow1_2/0_test_cancel_inverses_keep_original_workflow1.mlir b/test_cancel_inverses_keep_original_workflow1_2/0_test_cancel_inverses_keep_original_workflow1.mlir deleted file mode 100644 index 89ffaa9043..0000000000 --- a/test_cancel_inverses_keep_original_workflow1_2/0_test_cancel_inverses_keep_original_workflow1.mlir +++ /dev/null @@ -1,44 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow1 { - func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> tensor attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.000000e+00> : tensor - %0 = catalyst.launch_kernel @module_f::@f(%cst) : (tensor) -> tensor - return %0 : tensor - } - module @module_f { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<1> : tensor - %0 = quantum.alloc( 1) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit - %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %extracted_5 = tensor.extract %c[] : tensor - %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/1_EnforceRuntimeInvariantsPass.mlir b/test_cancel_inverses_keep_original_workflow1_2/1_EnforceRuntimeInvariantsPass.mlir deleted file mode 100644 index b455d31e30..0000000000 --- a/test_cancel_inverses_keep_original_workflow1_2/1_EnforceRuntimeInvariantsPass.mlir +++ /dev/null @@ -1,30 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow1 { - func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> tensor attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.000000e+00> : tensor - %0 = call @f_0(%cst) : (tensor) -> tensor - return %0 : tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/2_HLOLoweringPass.mlir b/test_cancel_inverses_keep_original_workflow1_2/2_HLOLoweringPass.mlir deleted file mode 100644 index 61a941fcc5..0000000000 --- a/test_cancel_inverses_keep_original_workflow1_2/2_HLOLoweringPass.mlir +++ /dev/null @@ -1,30 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow1 { - func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> tensor attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.000000e+00> : tensor - %0 = call @f_0(%cst) : (tensor) -> tensor - return %0 : tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/3_QuantumCompilationPass.mlir b/test_cancel_inverses_keep_original_workflow1_2/3_QuantumCompilationPass.mlir deleted file mode 100644 index 61a941fcc5..0000000000 --- a/test_cancel_inverses_keep_original_workflow1_2/3_QuantumCompilationPass.mlir +++ /dev/null @@ -1,30 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow1 { - func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> tensor attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.000000e+00> : tensor - %0 = call @f_0(%cst) : (tensor) -> tensor - return %0 : tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/4_BufferizationPass.mlir b/test_cancel_inverses_keep_original_workflow1_2/4_BufferizationPass.mlir deleted file mode 100644 index 8dc4bf2189..0000000000 --- a/test_cancel_inverses_keep_original_workflow1_2/4_BufferizationPass.mlir +++ /dev/null @@ -1,44 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow1 { - memref.global "private" constant @__constant_xf64 : memref = dense<1.000000e+00> {alignment = 64 : i64} - func.func public @jit_test_cancel_inverses_keep_original_workflow1() -> memref attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(3735928559 : index) : i64 - %1 = memref.get_global @__constant_xf64 : memref - %2 = call @f_0(%1) : (memref) -> memref - %3 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> - %4 = llvm.extractvalue %3[0] : !llvm.struct<(ptr, ptr, i64)> - %5 = llvm.ptrtoint %4 : !llvm.ptr to i64 - %6 = llvm.icmp "eq" %0, %5 : i64 - %7 = scf.if %6 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %2, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %2 : memref - } - return %7 : memref - } - func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %4 = quantum.expval %3 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %4, %alloc[] : memref - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %5 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/5_MLIRToLLVMDialect.mlir b/test_cancel_inverses_keep_original_workflow1_2/5_MLIRToLLVMDialect.mlir deleted file mode 100644 index ba4768c6db..0000000000 --- a/test_cancel_inverses_keep_original_workflow1_2/5_MLIRToLLVMDialect.mlir +++ /dev/null @@ -1,112 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow1 { - llvm.func @__catalyst__rt__finalize() - llvm.func @__catalyst__rt__initialize(!llvm.ptr) - llvm.func @__catalyst__rt__device_release() - llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) - llvm.func @__catalyst__qis__Expval(i64) -> f64 - llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 - llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr - llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr - llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} - llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) - llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr - llvm.mlir.global private constant @__constant_xf64(1.000000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 - llvm.func @jit_test_cancel_inverses_keep_original_workflow1() -> !llvm.struct<(ptr, ptr, i64)> attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %2 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr - %3 = llvm.mlir.constant(3735928559 : index) : i64 - %4 = llvm.mlir.constant(1 : index) : i64 - %5 = llvm.mlir.zero : !llvm.ptr - %6 = llvm.inttoptr %3 : i64 to !llvm.ptr - %7 = llvm.call @f_0(%6, %2, %0) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %8 = llvm.extractvalue %7[0] : !llvm.struct<(ptr, ptr, i64)> - %9 = llvm.ptrtoint %8 : !llvm.ptr to i64 - %10 = llvm.icmp "eq" %3, %9 : i64 - llvm.cond_br %10, ^bb1, ^bb2 - ^bb1: // pred: ^bb0 - %11 = llvm.getelementptr %5[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %12 = llvm.ptrtoint %11 : !llvm.ptr to i64 - %13 = llvm.call @_mlir_memref_to_llvm_alloc(%12) : (i64) -> !llvm.ptr - %14 = llvm.insertvalue %13, %1[0] : !llvm.struct<(ptr, ptr, i64)> - %15 = llvm.insertvalue %13, %14[1] : !llvm.struct<(ptr, ptr, i64)> - %16 = llvm.insertvalue %0, %15[2] : !llvm.struct<(ptr, ptr, i64)> - %17 = llvm.getelementptr %5[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %18 = llvm.ptrtoint %17 : !llvm.ptr to i64 - %19 = llvm.mul %18, %4 : i64 - %20 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64)> - %21 = llvm.extractvalue %7[2] : !llvm.struct<(ptr, ptr, i64)> - %22 = llvm.getelementptr inbounds %20[%21] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%13, %22, %19) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb3(%16 : !llvm.struct<(ptr, ptr, i64)>) - ^bb2: // pred: ^bb0 - llvm.br ^bb3(%7 : !llvm.struct<(ptr, ptr, i64)>) - ^bb3(%23: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 - llvm.br ^bb4 - ^bb4: // pred: ^bb3 - llvm.return %23 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow1(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { - llvm.call @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow1(%arg0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow1(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.call @jit_test_cancel_inverses_keep_original_workflow1() : () -> !llvm.struct<(ptr, ptr, i64)> - llvm.store %0, %arg0 : !llvm.struct<(ptr, ptr, i64)>, !llvm.ptr - llvm.return - } - llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(3 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(1 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 - %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 - %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 - %23 = llvm.add %22, %1 : i64 - %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr - %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 - %26 = llvm.sub %1, %2 : i64 - %27 = llvm.add %25, %26 : i64 - %28 = llvm.urem %27, %1 : i64 - %29 = llvm.sub %27, %28 : i64 - %30 = llvm.inttoptr %29 : i64 to !llvm.ptr - %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %20, %30 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @setup() { - %0 = llvm.mlir.zero : !llvm.ptr - llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @teardown() { - llvm.call @__catalyst__rt__finalize() : () -> () - llvm.return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow1_2/6_llvm_ir.ll b/test_cancel_inverses_keep_original_workflow1_2/6_llvm_ir.ll deleted file mode 100644 index d7163e9805..0000000000 --- a/test_cancel_inverses_keep_original_workflow1_2/6_llvm_ir.ll +++ /dev/null @@ -1,112 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" - -@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" -@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" -@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" -@__constant_xf64 = private constant double 1.000000e+00, align 64 - -declare void @__catalyst__rt__finalize() - -declare void @__catalyst__rt__initialize(ptr) - -declare void @__catalyst__rt__device_release() - -declare void @__catalyst__rt__qubit_release_array(ptr) - -declare double @__catalyst__qis__Expval(i64) - -declare i64 @__catalyst__qis__NamedObs(i64, ptr) - -declare void @__catalyst__qis__RX(double, ptr, ptr) - -declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) - -declare ptr @__catalyst__rt__qubit_allocate_array(i64) - -declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) - -declare ptr @_mlir_memref_to_llvm_alloc(i64) - -define { ptr, ptr, i64 } @jit_test_cancel_inverses_keep_original_workflow1() { - %1 = call { ptr, ptr, i64 } @f_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) - %2 = extractvalue { ptr, ptr, i64 } %1, 0 - %3 = ptrtoint ptr %2 to i64 - %4 = icmp eq i64 3735928559, %3 - br i1 %4, label %5, label %13 - -5: ; preds = %0 - %6 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %7 = insertvalue { ptr, ptr, i64 } poison, ptr %6, 0 - %8 = insertvalue { ptr, ptr, i64 } %7, ptr %6, 1 - %9 = insertvalue { ptr, ptr, i64 } %8, i64 0, 2 - %10 = extractvalue { ptr, ptr, i64 } %1, 1 - %11 = extractvalue { ptr, ptr, i64 } %1, 2 - %12 = getelementptr inbounds double, ptr %10, i64 %11 - call void @llvm.memcpy.p0.p0.i64(ptr %6, ptr %12, i64 8, i1 false) - br label %14 - -13: ; preds = %0 - br label %14 - -14: ; preds = %5, %13 - %15 = phi { ptr, ptr, i64 } [ %1, %13 ], [ %9, %5 ] - br label %16 - -16: ; preds = %14 - ret { ptr, ptr, i64 } %15 -} - -define void @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow1(ptr %0, ptr %1) { - call void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow1(ptr %0) - ret void -} - -define void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow1(ptr %0) { - %2 = call { ptr, ptr, i64 } @jit_test_cancel_inverses_keep_original_workflow1() - store { ptr, ptr, i64 } %2, ptr %0, align 8 - ret void -} - -define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) - %9 = call double @__catalyst__qis__Expval(i64 %8) - %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %11 = ptrtoint ptr %10 to i64 - %12 = add i64 %11, 63 - %13 = urem i64 %12, 64 - %14 = sub i64 %12, %13 - %15 = inttoptr i64 %14 to ptr - %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 - %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 - %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 - store double %9, ptr %15, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %18 -} - -define void @setup() { - call void @__catalyst__rt__initialize(ptr null) - ret void -} - -define void @teardown() { - call void @__catalyst__rt__finalize() - ret void -} - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 - -attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_cancel_inverses_keep_original_workflow1_2/test_cancel_inverses_keep_original_workflow1.o b/test_cancel_inverses_keep_original_workflow1_2/test_cancel_inverses_keep_original_workflow1.o deleted file mode 100644 index 5d5f22bd7a10bd2dc12699c992fde504c8073249..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3192 zcmc&$T}&KR6h6}hx>#ILP^xXpHhqAYZkHcp)Rc5pYWhH0f|&Hdco~+vFlBajJ2U)j zR}&&W_z3>Q7d86`#0TGNA|{%U_)u$V(+5o!S`++B8lPN~6~8lc2bP6Rv@hP|&Nt_L z=bU@anVEa%#$Uhx-9)4j24Cth!-sH*Vq!dj`HshW;=W6P9Wc7s2P2RVHE(=w3v*1N9a-BI!Gt9YLw z9-apsA(~W_2fer+#q`U0a);tYS>F=&pH-oe=njTg?=Gt zFOKJjzHD$`uueHYu!8(|dcb{Wo1hQXeF3*`ToD93GoAyxH--9Hx?edXV%uQ<>WDLu8+;BP6@(=~YYfzx^oe%;>ysI3P7 zgW_wguk@r{8zyb;gx1p3K~cowJ>=fDKY|+QLS*z4?PI*&M8`4DVy-EhAPx;gTG)p9 z*Dwo;SM?EML<9Z}@bijS^)Wvb@E?I6RlKT?D&v0+K2c-+BI<@u>|5Ytz)yj#z-1uL zkJ#Hl)EIMt*aKr(U^8$Oh+1M7fR6yr0v`u<10MxOf!H?(kNenv6j%qj&By*0AYOvO zCLjBY$PxQ%jO)Xm8yf)fy2pWNWQ^;A=^*zH*kACmVP4^=!i2)8LIB%0tO2nvo?v_! zr4*FRh;t({uVhB77a3JDBl3wPl+5@LWX_A@F(U8CH|&Ikf^m{%OfHhg&45=n9{`yj zWgCp^m@Frh%x0dylD`I4%FnTk*unYQ$1)lmoR4ooZbpz>9311El7n~jJtg}r(GA?N zeej*!R&wxN6d`j?!6@LSQf@-LO8F9mN_nBmK3>K124894TE#zG#lK!9=c?>UJlM`F z@Iw=9p2Bv8+W&OZ%s?-NZrgeee`N<++0vA{Q`2Z%&KOB449jr$M!0G?LR`cFFn(#w zA#uQ-FC6JkX9+)px;>tmwGQw% zh%seaTCT{tw&)p$W!f}sk(Oy&ri7ajra6-qUjIn^Kd056r{(o}_%fNS (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.000000e+00> : tensor - %0 = catalyst.launch_kernel @module_f::@f(%cst) : (tensor) -> tensor - %1 = catalyst.launch_kernel @module_f_0::@f_1(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - module @module_f { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - transform.yield - } - } - func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<1> : tensor - %0 = quantum.alloc( 1) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit - %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %extracted_5 = tensor.extract %c[] : tensor - %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - module @module_f_0 { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @f_1(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<1> : tensor - %0 = quantum.alloc( 1) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit - %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %extracted_5 = tensor.extract %c[] : tensor - %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/1_EnforceRuntimeInvariantsPass.mlir b/test_cancel_inverses_keep_original_workflow2_2/1_EnforceRuntimeInvariantsPass.mlir deleted file mode 100644 index 8fdb8e12bc..0000000000 --- a/test_cancel_inverses_keep_original_workflow2_2/1_EnforceRuntimeInvariantsPass.mlir +++ /dev/null @@ -1,48 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow2 { - func.func public @jit_test_cancel_inverses_keep_original_workflow2() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = stablehlo.constant dense<1.000000e+00> : tensor - %0 = call @f_0(%cst) : (tensor) -> tensor - %1 = call @f_1_0(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/2_HLOLoweringPass.mlir b/test_cancel_inverses_keep_original_workflow2_2/2_HLOLoweringPass.mlir deleted file mode 100644 index 316c298aa8..0000000000 --- a/test_cancel_inverses_keep_original_workflow2_2/2_HLOLoweringPass.mlir +++ /dev/null @@ -1,48 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow2 { - func.func public @jit_test_cancel_inverses_keep_original_workflow2() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.000000e+00> : tensor - %0 = call @f_0(%cst) : (tensor) -> tensor - %1 = call @f_1_0(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/3_QuantumCompilationPass.mlir b/test_cancel_inverses_keep_original_workflow2_2/3_QuantumCompilationPass.mlir deleted file mode 100644 index 316c298aa8..0000000000 --- a/test_cancel_inverses_keep_original_workflow2_2/3_QuantumCompilationPass.mlir +++ /dev/null @@ -1,48 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow2 { - func.func public @jit_test_cancel_inverses_keep_original_workflow2() -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %cst = arith.constant dense<1.000000e+00> : tensor - %0 = call @f_0(%cst) : (tensor) -> tensor - %1 = call @f_1_0(%cst) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/4_BufferizationPass.mlir b/test_cancel_inverses_keep_original_workflow2_2/4_BufferizationPass.mlir deleted file mode 100644 index 35ac832e41..0000000000 --- a/test_cancel_inverses_keep_original_workflow2_2/4_BufferizationPass.mlir +++ /dev/null @@ -1,74 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow2 { - memref.global "private" constant @__constant_xf64 : memref = dense<1.000000e+00> {alignment = 64 : i64} - func.func public @jit_test_cancel_inverses_keep_original_workflow2() -> (memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(3735928559 : index) : i64 - %1 = memref.get_global @__constant_xf64 : memref - %2 = call @f_0(%1) : (memref) -> memref - %3 = call @f_1_0(%1) : (memref) -> memref - %4 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> - %5 = llvm.extractvalue %4[0] : !llvm.struct<(ptr, ptr, i64)> - %6 = llvm.ptrtoint %5 : !llvm.ptr to i64 - %7 = llvm.icmp "eq" %0, %6 : i64 - %8 = scf.if %7 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %2, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %2 : memref - } - %9 = builtin.unrealized_conversion_cast %3 : memref to !llvm.struct<(ptr, ptr, i64)> - %10 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> - %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 - %12 = llvm.icmp "eq" %0, %11 : i64 - %13 = scf.if %12 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %3, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %3 : memref - } - return %8, %13 : memref, memref - } - func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %4 = quantum.expval %3 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %4, %alloc[] : memref - %5 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %5 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func public @f_1_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %4 = quantum.expval %3 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %4, %alloc[] : memref - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %5 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/5_MLIRToLLVMDialect.mlir b/test_cancel_inverses_keep_original_workflow2_2/5_MLIRToLLVMDialect.mlir deleted file mode 100644 index 5ea3d0d971..0000000000 --- a/test_cancel_inverses_keep_original_workflow2_2/5_MLIRToLLVMDialect.mlir +++ /dev/null @@ -1,185 +0,0 @@ -module @test_cancel_inverses_keep_original_workflow2 { - llvm.func @__catalyst__rt__finalize() - llvm.func @__catalyst__rt__initialize(!llvm.ptr) - llvm.func @__catalyst__rt__device_release() - llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) - llvm.func @__catalyst__qis__Expval(i64) -> f64 - llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 - llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr - llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr - llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} - llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) - llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr - llvm.mlir.global private constant @__constant_xf64(1.000000e+00 : f64) {addr_space = 0 : i32, alignment = 64 : i64} : f64 - llvm.func @jit_test_cancel_inverses_keep_original_workflow2() -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %1 = llvm.mlir.constant(0 : index) : i64 - %2 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %3 = llvm.mlir.addressof @__constant_xf64 : !llvm.ptr - %4 = llvm.mlir.constant(3735928559 : index) : i64 - %5 = llvm.mlir.constant(1 : index) : i64 - %6 = llvm.mlir.zero : !llvm.ptr - %7 = llvm.inttoptr %4 : i64 to !llvm.ptr - %8 = llvm.call @f_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %9 = llvm.call @f_1_0(%7, %3, %1) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %10 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> - %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 - %12 = llvm.icmp "eq" %4, %11 : i64 - llvm.cond_br %12, ^bb1, ^bb2 - ^bb1: // pred: ^bb0 - %13 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %14 = llvm.ptrtoint %13 : !llvm.ptr to i64 - %15 = llvm.call @_mlir_memref_to_llvm_alloc(%14) : (i64) -> !llvm.ptr - %16 = llvm.insertvalue %15, %2[0] : !llvm.struct<(ptr, ptr, i64)> - %17 = llvm.insertvalue %15, %16[1] : !llvm.struct<(ptr, ptr, i64)> - %18 = llvm.insertvalue %1, %17[2] : !llvm.struct<(ptr, ptr, i64)> - %19 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %20 = llvm.ptrtoint %19 : !llvm.ptr to i64 - %21 = llvm.mul %20, %5 : i64 - %22 = llvm.extractvalue %8[1] : !llvm.struct<(ptr, ptr, i64)> - %23 = llvm.extractvalue %8[2] : !llvm.struct<(ptr, ptr, i64)> - %24 = llvm.getelementptr inbounds %22[%23] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%15, %24, %21) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb3(%18 : !llvm.struct<(ptr, ptr, i64)>) - ^bb2: // pred: ^bb0 - llvm.br ^bb3(%8 : !llvm.struct<(ptr, ptr, i64)>) - ^bb3(%25: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 - llvm.br ^bb4 - ^bb4: // pred: ^bb3 - %26 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> - %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 - %28 = llvm.icmp "eq" %4, %27 : i64 - llvm.cond_br %28, ^bb5, ^bb6 - ^bb5: // pred: ^bb4 - %29 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %30 = llvm.ptrtoint %29 : !llvm.ptr to i64 - %31 = llvm.call @_mlir_memref_to_llvm_alloc(%30) : (i64) -> !llvm.ptr - %32 = llvm.insertvalue %31, %2[0] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %1, %33[2] : !llvm.struct<(ptr, ptr, i64)> - %35 = llvm.getelementptr %6[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %36 = llvm.ptrtoint %35 : !llvm.ptr to i64 - %37 = llvm.mul %36, %5 : i64 - %38 = llvm.extractvalue %9[1] : !llvm.struct<(ptr, ptr, i64)> - %39 = llvm.extractvalue %9[2] : !llvm.struct<(ptr, ptr, i64)> - %40 = llvm.getelementptr inbounds %38[%39] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%31, %40, %37) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb7(%34 : !llvm.struct<(ptr, ptr, i64)>) - ^bb6: // pred: ^bb4 - llvm.br ^bb7(%9 : !llvm.struct<(ptr, ptr, i64)>) - ^bb7(%41: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 - llvm.br ^bb8 - ^bb8: // pred: ^bb7 - %42 = llvm.insertvalue %25, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %43 = llvm.insertvalue %41, %42[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.return %43 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - } - llvm.func @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow2(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { - llvm.call @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow2(%arg0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow2(%arg0: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.call @jit_test_cancel_inverses_keep_original_workflow2() : () -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.store %0, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr - llvm.return - } - llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(3 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(1 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () - llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 - %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 - %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 - %23 = llvm.add %22, %1 : i64 - %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr - %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 - %26 = llvm.sub %1, %2 : i64 - %27 = llvm.add %25, %26 : i64 - %28 = llvm.urem %27, %1 : i64 - %29 = llvm.sub %27, %28 : i64 - %30 = llvm.inttoptr %29 : i64 to !llvm.ptr - %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %20, %30 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func internal @f_1_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(3 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(1 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 - %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 - %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 - %23 = llvm.add %22, %1 : i64 - %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr - %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 - %26 = llvm.sub %1, %2 : i64 - %27 = llvm.add %25, %26 : i64 - %28 = llvm.urem %27, %1 : i64 - %29 = llvm.sub %27, %28 : i64 - %30 = llvm.inttoptr %29 : i64 to !llvm.ptr - %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %20, %30 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @setup() { - %0 = llvm.mlir.zero : !llvm.ptr - llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @teardown() { - llvm.call @__catalyst__rt__finalize() : () -> () - llvm.return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_keep_original_workflow2_2/6_llvm_ir.ll b/test_cancel_inverses_keep_original_workflow2_2/6_llvm_ir.ll deleted file mode 100644 index 4aace33fee..0000000000 --- a/test_cancel_inverses_keep_original_workflow2_2/6_llvm_ir.ll +++ /dev/null @@ -1,167 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" - -@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" -@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" -@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" -@__constant_xf64 = private constant double 1.000000e+00, align 64 - -declare void @__catalyst__rt__finalize() - -declare void @__catalyst__rt__initialize(ptr) - -declare void @__catalyst__rt__device_release() - -declare void @__catalyst__rt__qubit_release_array(ptr) - -declare double @__catalyst__qis__Expval(i64) - -declare i64 @__catalyst__qis__NamedObs(i64, ptr) - -declare void @__catalyst__qis__Hadamard(ptr, ptr) - -declare void @__catalyst__qis__RX(double, ptr, ptr) - -declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) - -declare ptr @__catalyst__rt__qubit_allocate_array(i64) - -declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) - -declare ptr @_mlir_memref_to_llvm_alloc(i64) - -define { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_cancel_inverses_keep_original_workflow2() { - %1 = call { ptr, ptr, i64 } @f_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) - %2 = call { ptr, ptr, i64 } @f_1_0(ptr inttoptr (i64 3735928559 to ptr), ptr @__constant_xf64, i64 0) - %3 = extractvalue { ptr, ptr, i64 } %1, 0 - %4 = ptrtoint ptr %3 to i64 - %5 = icmp eq i64 3735928559, %4 - br i1 %5, label %6, label %14 - -6: ; preds = %0 - %7 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %8 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 - %9 = insertvalue { ptr, ptr, i64 } %8, ptr %7, 1 - %10 = insertvalue { ptr, ptr, i64 } %9, i64 0, 2 - %11 = extractvalue { ptr, ptr, i64 } %1, 1 - %12 = extractvalue { ptr, ptr, i64 } %1, 2 - %13 = getelementptr inbounds double, ptr %11, i64 %12 - call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %13, i64 8, i1 false) - br label %15 - -14: ; preds = %0 - br label %15 - -15: ; preds = %6, %14 - %16 = phi { ptr, ptr, i64 } [ %1, %14 ], [ %10, %6 ] - br label %17 - -17: ; preds = %15 - %18 = extractvalue { ptr, ptr, i64 } %2, 0 - %19 = ptrtoint ptr %18 to i64 - %20 = icmp eq i64 3735928559, %19 - br i1 %20, label %21, label %29 - -21: ; preds = %17 - %22 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %23 = insertvalue { ptr, ptr, i64 } poison, ptr %22, 0 - %24 = insertvalue { ptr, ptr, i64 } %23, ptr %22, 1 - %25 = insertvalue { ptr, ptr, i64 } %24, i64 0, 2 - %26 = extractvalue { ptr, ptr, i64 } %2, 1 - %27 = extractvalue { ptr, ptr, i64 } %2, 2 - %28 = getelementptr inbounds double, ptr %26, i64 %27 - call void @llvm.memcpy.p0.p0.i64(ptr %22, ptr %28, i64 8, i1 false) - br label %30 - -29: ; preds = %17 - br label %30 - -30: ; preds = %21, %29 - %31 = phi { ptr, ptr, i64 } [ %2, %29 ], [ %25, %21 ] - br label %32 - -32: ; preds = %30 - %33 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %16, 0 - %34 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %33, { ptr, ptr, i64 } %31, 1 - ret { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %34 -} - -define void @_catalyst_pyface_jit_test_cancel_inverses_keep_original_workflow2(ptr %0, ptr %1) { - call void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow2(ptr %0) - ret void -} - -define void @_catalyst_ciface_jit_test_cancel_inverses_keep_original_workflow2(ptr %0) { - %2 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_cancel_inverses_keep_original_workflow2() - store { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %2, ptr %0, align 8 - ret void -} - -define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - call void @__catalyst__qis__Hadamard(ptr %6, ptr null) - call void @__catalyst__qis__Hadamard(ptr %6, ptr null) - %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) - %9 = call double @__catalyst__qis__Expval(i64 %8) - %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %11 = ptrtoint ptr %10 to i64 - %12 = add i64 %11, 63 - %13 = urem i64 %12, 64 - %14 = sub i64 %12, %13 - %15 = inttoptr i64 %14 to ptr - %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 - %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 - %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 - store double %9, ptr %15, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %18 -} - -define internal { ptr, ptr, i64 } @f_1_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) - %9 = call double @__catalyst__qis__Expval(i64 %8) - %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %11 = ptrtoint ptr %10 to i64 - %12 = add i64 %11, 63 - %13 = urem i64 %12, 64 - %14 = sub i64 %12, %13 - %15 = inttoptr i64 %14 to ptr - %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 - %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 - %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 - store double %9, ptr %15, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %18 -} - -define void @setup() { - call void @__catalyst__rt__initialize(ptr null) - ret void -} - -define void @teardown() { - call void @__catalyst__rt__finalize() - ret void -} - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 - -attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_cancel_inverses_keep_original_workflow2_2/test_cancel_inverses_keep_original_workflow2.o b/test_cancel_inverses_keep_original_workflow2_2/test_cancel_inverses_keep_original_workflow2.o deleted file mode 100644 index e6c8f2ad10b13c813b2c5298a2d876df1b76185a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3960 zcmc&%OKcNI7@my-I6R!tK!JjYs~!>+j7fq@Rj_ai6e>j!(NyA4b+WO?$&&TjtT!*x zN|xZjp@*bG;zFw&6HYz!PzfYlsfXO4Rf|wXrA-Kx=|iGb57|m?`u)4JiS6Kua-bv4 ze*6F5|D0X#jBo$-+us`*Qy2za>M?_LxP&n=c3@t1Syx6DQOMaKV|z(e&+-KR;5?Braw`EjuZ&laae}h;;u^+e zseXtGqq^$@xIbbp*R&A7aj2Cv)ZxGN+bJF~F|d zhvH802yBnS_5^c^h&PRREeiWZsbf7sC4a^a1Yf0?KOcl`XWV&2e#kQyXt+L)85}#e z*rve06>;_;Uz9nhXNwK{IoQu5M>&Tz+hVtZ+XH-;P(o19vwlB3BFaz*g2fq!>c^HU03+v*}gALH{giT8v zwZ)y%_&YOL_sK$l-z|;bnxQo*jej*w^3p|y=b_Blh(Y=y{MT${PW@))1U50Ju7Nqq z8gL3joHr4Nxp9_`D)6hHq1^DBz??*F6E6et+DyC!e1Nrnfc04jw7AcqjjcQrw>I?a z=Omdi)Qdit5-*Y7MjxKO@_r8bfwEYxZ6hlM8&=}mjq#HEo?xAdw5BCC8GLx*lOmoO zdU4~septgftkpd7m&T9Hps(lF-}C5$o;SVo)T{r@tKR`|Pd&z4(}{GV^^Ne`s-6>j z!>z_pn)eNvhGsyyABsU?8bap=K3UM5${6CKvgln}|9}PK{&%(Xkgi%8vy8-T^u3%g zbJ4_rspTxqP@~;urazicEma@OSzH*yQC;hcX2-07jM2HTy(5~_ED^yMcTnvYxoB1x z#+a@eg6n=Ja#$Al`Jq0|;(ow=$uY2%B|L@n_=ss|=^`N4su%82b{4qe0gf9>zWfQr^oz%9{jI z-X0+3?FLfbI1oKV4oIZ)4%N{Fq&n(>RL3ITC#s_eq&gNnjM+e{m!R1|KVUxOPfnUShArxWuqT z0Qs%8feno9Cd9cWRFE>^CdgA#CPY12bNG^dSlZt}Ad+cuX;5f49*U)5lRsub%0G~dd;h$6 zie&iu=e?_t8xh3+j=1jyCVyiumRH zxhngMRrb*;9-DoIe{&Tt-zQjk;{!l>zAIJsj6d7X#BpHvHy3VNT<#C5u4kYZTs2K~ z4F5WwXk`jrsJWU(NinP?1lJ7Bs*G@6%W-}R8)WiyUyku7?1?-ltf4H!pB>dqW=4!B z_#Yq54y$@4K@Fs^YwFqsv6`Vmv>KeORd!VA>y~>`O{!@WQ%O-mcZqnv!0xPzv@k55 zwM^blmT6rxd0M1Rk>XZ{>-un-yGzUX|Fh9oJV>{%GiRAjTKX5LqW00$YX_KarL&!= zfBDtOj-^yQ%5yk6SOVveglZ&k$kB{poK{4R4+@dx8B^=0#pfd#b1 ULA7+a6}7w9{fwu$dua#!1AxJvf&c&j diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/0_test_cancel_inverses_lowering_transform_applied_workflow.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/0_test_cancel_inverses_lowering_transform_applied_workflow.mlir deleted file mode 100644 index e70fb2caad..0000000000 --- a/test_cancel_inverses_lowering_transform_applied_workflow_2/0_test_cancel_inverses_lowering_transform_applied_workflow.mlir +++ /dev/null @@ -1,102 +0,0 @@ -module @test_cancel_inverses_lowering_transform_applied_workflow { - func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: tensor) -> (tensor, tensor, tensor) attributes {llvm.emit_c_interface} { - %0 = catalyst.launch_kernel @module_f::@f(%arg0) : (tensor) -> tensor - %1 = catalyst.launch_kernel @module_g::@g(%arg0) : (tensor) -> tensor - %2 = catalyst.launch_kernel @module_h::@h(%arg0) : (tensor) -> tensor - return %0, %1, %2 : tensor, tensor, tensor - } - module @module_f { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<1> : tensor - %0 = quantum.alloc( 1) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit - %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %extracted_5 = tensor.extract %c[] : tensor - %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - module @module_g { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - transform.yield - } - } - func.func public @g(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<1> : tensor - %0 = quantum.alloc( 1) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %out_qubits_3 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit - %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %extracted_5 = tensor.extract %c[] : tensor - %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - module @module_h { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @h(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<1> : tensor - %0 = quantum.alloc( 1) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits_3 = quantum.custom "RX"(%extracted_2) %out_qubits : !quantum.bit - %out_qubits_4 = quantum.custom "Hadamard"() %out_qubits_3 : !quantum.bit - %2 = quantum.namedobs %out_qubits_4[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %extracted_5 = tensor.extract %c[] : tensor - %4 = quantum.insert %0[%extracted_5], %out_qubits_4 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/1_EnforceRuntimeInvariantsPass.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/1_EnforceRuntimeInvariantsPass.mlir deleted file mode 100644 index dd3ab9f8dd..0000000000 --- a/test_cancel_inverses_lowering_transform_applied_workflow_2/1_EnforceRuntimeInvariantsPass.mlir +++ /dev/null @@ -1,65 +0,0 @@ -module @test_cancel_inverses_lowering_transform_applied_workflow { - func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: tensor) -> (tensor, tensor, tensor) attributes {llvm.emit_c_interface} { - %0 = call @f_0(%arg0) : (tensor) -> tensor - %1 = call @g_0(%arg0) : (tensor) -> tensor - %2 = call @h_0(%arg0) : (tensor) -> tensor - return %0, %1, %2 : tensor, tensor, tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits_0 = quantum.custom "RX"(%extracted) %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/2_HLOLoweringPass.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/2_HLOLoweringPass.mlir deleted file mode 100644 index dd3ab9f8dd..0000000000 --- a/test_cancel_inverses_lowering_transform_applied_workflow_2/2_HLOLoweringPass.mlir +++ /dev/null @@ -1,65 +0,0 @@ -module @test_cancel_inverses_lowering_transform_applied_workflow { - func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: tensor) -> (tensor, tensor, tensor) attributes {llvm.emit_c_interface} { - %0 = call @f_0(%arg0) : (tensor) -> tensor - %1 = call @g_0(%arg0) : (tensor) -> tensor - %2 = call @h_0(%arg0) : (tensor) -> tensor - return %0, %1, %2 : tensor, tensor, tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits_0 = quantum.custom "RX"(%extracted) %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/3_QuantumCompilationPass.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/3_QuantumCompilationPass.mlir deleted file mode 100644 index dd3ab9f8dd..0000000000 --- a/test_cancel_inverses_lowering_transform_applied_workflow_2/3_QuantumCompilationPass.mlir +++ /dev/null @@ -1,65 +0,0 @@ -module @test_cancel_inverses_lowering_transform_applied_workflow { - func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: tensor) -> (tensor, tensor, tensor) attributes {llvm.emit_c_interface} { - %0 = call @f_0(%arg0) : (tensor) -> tensor - %1 = call @g_0(%arg0) : (tensor) -> tensor - %2 = call @h_0(%arg0) : (tensor) -> tensor - return %0, %1, %2 : tensor, tensor, tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @g_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @h_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits_0 = quantum.custom "RX"(%extracted) %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %2 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %3 = quantum.expval %2 : f64 - %from_elements = tensor.from_elements %3 : tensor - %4 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %4 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/4_BufferizationPass.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/4_BufferizationPass.mlir deleted file mode 100644 index c26306caaa..0000000000 --- a/test_cancel_inverses_lowering_transform_applied_workflow_2/4_BufferizationPass.mlir +++ /dev/null @@ -1,102 +0,0 @@ -module @test_cancel_inverses_lowering_transform_applied_workflow { - func.func public @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: memref) -> (memref, memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(3735928559 : index) : i64 - %1 = call @f_0(%arg0) : (memref) -> memref - %2 = call @g_0(%arg0) : (memref) -> memref - %3 = call @h_0(%arg0) : (memref) -> memref - %4 = builtin.unrealized_conversion_cast %1 : memref to !llvm.struct<(ptr, ptr, i64)> - %5 = llvm.extractvalue %4[0] : !llvm.struct<(ptr, ptr, i64)> - %6 = llvm.ptrtoint %5 : !llvm.ptr to i64 - %7 = llvm.icmp "eq" %0, %6 : i64 - %8 = scf.if %7 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %1, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %1 : memref - } - %9 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> - %10 = llvm.extractvalue %9[0] : !llvm.struct<(ptr, ptr, i64)> - %11 = llvm.ptrtoint %10 : !llvm.ptr to i64 - %12 = llvm.icmp "eq" %0, %11 : i64 - %13 = scf.if %12 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %2, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %2 : memref - } - %14 = builtin.unrealized_conversion_cast %3 : memref to !llvm.struct<(ptr, ptr, i64)> - %15 = llvm.extractvalue %14[0] : !llvm.struct<(ptr, ptr, i64)> - %16 = llvm.ptrtoint %15 : !llvm.ptr to i64 - %17 = llvm.icmp "eq" %0, %16 : i64 - %18 = scf.if %17 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %3, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %3 : memref - } - return %8, %13, %18 : memref, memref, memref - } - func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliZ] : !quantum.obs - %4 = quantum.expval %3 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %4, %alloc[] : memref - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - quantum.dealloc %5 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func public @g_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %4 = quantum.expval %3 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %4, %alloc[] : memref - %5 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %5 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func public @h_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 1) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %out_qubits = quantum.custom "Hadamard"() %1 : !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits_0 = quantum.custom "RX"(%2) %out_qubits : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits_1[ PauliZ] : !quantum.obs - %4 = quantum.expval %3 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %4, %alloc[] : memref - %5 = quantum.insert %0[ 0], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %5 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/5_MLIRToLLVMDialect.mlir b/test_cancel_inverses_lowering_transform_applied_workflow_2/5_MLIRToLLVMDialect.mlir deleted file mode 100644 index 647e8a6261..0000000000 --- a/test_cancel_inverses_lowering_transform_applied_workflow_2/5_MLIRToLLVMDialect.mlir +++ /dev/null @@ -1,258 +0,0 @@ -module @test_cancel_inverses_lowering_transform_applied_workflow { - llvm.func @__catalyst__rt__finalize() - llvm.func @__catalyst__rt__initialize(!llvm.ptr) - llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__device_release() - llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) - llvm.func @__catalyst__qis__Expval(i64) -> f64 - llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 - llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr - llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr - llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} - llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) - llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr - llvm.func @jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %1 = llvm.mlir.constant(0 : index) : i64 - %2 = llvm.mlir.zero : !llvm.ptr - %3 = llvm.mlir.constant(1 : index) : i64 - %4 = llvm.mlir.constant(3735928559 : index) : i64 - %5 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %6 = llvm.call @f_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %7 = llvm.call @g_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %8 = llvm.call @h_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %9 = llvm.extractvalue %6[0] : !llvm.struct<(ptr, ptr, i64)> - %10 = llvm.ptrtoint %9 : !llvm.ptr to i64 - %11 = llvm.icmp "eq" %4, %10 : i64 - llvm.cond_br %11, ^bb1, ^bb2 - ^bb1: // pred: ^bb0 - %12 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %13 = llvm.ptrtoint %12 : !llvm.ptr to i64 - %14 = llvm.call @_mlir_memref_to_llvm_alloc(%13) : (i64) -> !llvm.ptr - %15 = llvm.insertvalue %14, %5[0] : !llvm.struct<(ptr, ptr, i64)> - %16 = llvm.insertvalue %14, %15[1] : !llvm.struct<(ptr, ptr, i64)> - %17 = llvm.insertvalue %1, %16[2] : !llvm.struct<(ptr, ptr, i64)> - %18 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %19 = llvm.ptrtoint %18 : !llvm.ptr to i64 - %20 = llvm.mul %19, %3 : i64 - %21 = llvm.extractvalue %6[1] : !llvm.struct<(ptr, ptr, i64)> - %22 = llvm.extractvalue %6[2] : !llvm.struct<(ptr, ptr, i64)> - %23 = llvm.getelementptr inbounds %21[%22] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%14, %23, %20) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb3(%17 : !llvm.struct<(ptr, ptr, i64)>) - ^bb2: // pred: ^bb0 - llvm.br ^bb3(%6 : !llvm.struct<(ptr, ptr, i64)>) - ^bb3(%24: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 - llvm.br ^bb4 - ^bb4: // pred: ^bb3 - %25 = llvm.extractvalue %7[0] : !llvm.struct<(ptr, ptr, i64)> - %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 - %27 = llvm.icmp "eq" %4, %26 : i64 - llvm.cond_br %27, ^bb5, ^bb6 - ^bb5: // pred: ^bb4 - %28 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %29 = llvm.ptrtoint %28 : !llvm.ptr to i64 - %30 = llvm.call @_mlir_memref_to_llvm_alloc(%29) : (i64) -> !llvm.ptr - %31 = llvm.insertvalue %30, %5[0] : !llvm.struct<(ptr, ptr, i64)> - %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %1, %32[2] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %35 = llvm.ptrtoint %34 : !llvm.ptr to i64 - %36 = llvm.mul %35, %3 : i64 - %37 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64)> - %38 = llvm.extractvalue %7[2] : !llvm.struct<(ptr, ptr, i64)> - %39 = llvm.getelementptr inbounds %37[%38] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%30, %39, %36) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb7(%33 : !llvm.struct<(ptr, ptr, i64)>) - ^bb6: // pred: ^bb4 - llvm.br ^bb7(%7 : !llvm.struct<(ptr, ptr, i64)>) - ^bb7(%40: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 - llvm.br ^bb8 - ^bb8: // pred: ^bb7 - %41 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> - %42 = llvm.ptrtoint %41 : !llvm.ptr to i64 - %43 = llvm.icmp "eq" %4, %42 : i64 - llvm.cond_br %43, ^bb9, ^bb10 - ^bb9: // pred: ^bb8 - %44 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %45 = llvm.ptrtoint %44 : !llvm.ptr to i64 - %46 = llvm.call @_mlir_memref_to_llvm_alloc(%45) : (i64) -> !llvm.ptr - %47 = llvm.insertvalue %46, %5[0] : !llvm.struct<(ptr, ptr, i64)> - %48 = llvm.insertvalue %46, %47[1] : !llvm.struct<(ptr, ptr, i64)> - %49 = llvm.insertvalue %1, %48[2] : !llvm.struct<(ptr, ptr, i64)> - %50 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %51 = llvm.ptrtoint %50 : !llvm.ptr to i64 - %52 = llvm.mul %51, %3 : i64 - %53 = llvm.extractvalue %8[1] : !llvm.struct<(ptr, ptr, i64)> - %54 = llvm.extractvalue %8[2] : !llvm.struct<(ptr, ptr, i64)> - %55 = llvm.getelementptr inbounds %53[%54] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%46, %55, %52) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb11(%49 : !llvm.struct<(ptr, ptr, i64)>) - ^bb10: // pred: ^bb8 - llvm.br ^bb11(%8 : !llvm.struct<(ptr, ptr, i64)>) - ^bb11(%56: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb9, ^bb10 - llvm.br ^bb12 - ^bb12: // pred: ^bb11 - %57 = llvm.insertvalue %24, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %58 = llvm.insertvalue %40, %57[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %59 = llvm.insertvalue %56, %58[2] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.return %59 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - } - llvm.func @_catalyst_pyface_jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { - %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr)> - %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr)> - llvm.call @_catalyst_ciface_jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0, %1) : (!llvm.ptr, !llvm.ptr) -> () - llvm.return - } - llvm.func @_catalyst_ciface_jit_test_cancel_inverses_lowering_transform_applied_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr, i64)> - %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr, i64)> - %2 = llvm.extractvalue %0[1] : !llvm.struct<(ptr, ptr, i64)> - %3 = llvm.extractvalue %0[2] : !llvm.struct<(ptr, ptr, i64)> - %4 = llvm.call @jit_test_cancel_inverses_lowering_transform_applied_workflow(%1, %2, %3) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.store %4, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr - llvm.return - } - llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(3 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(1 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 - %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 - %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 - %23 = llvm.add %22, %1 : i64 - %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr - %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 - %26 = llvm.sub %1, %2 : i64 - %27 = llvm.add %25, %26 : i64 - %28 = llvm.urem %27, %1 : i64 - %29 = llvm.sub %27, %28 : i64 - %30 = llvm.inttoptr %29 : i64 to !llvm.ptr - %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %20, %30 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func internal @g_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(3 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(1 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () - llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 - %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 - %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 - %23 = llvm.add %22, %1 : i64 - %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr - %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 - %26 = llvm.sub %1, %2 : i64 - %27 = llvm.add %25, %26 : i64 - %28 = llvm.urem %27, %1 : i64 - %29 = llvm.sub %27, %28 : i64 - %30 = llvm.inttoptr %29 : i64 to !llvm.ptr - %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %20, %30 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func internal @h_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(3 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(1 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - llvm.call @__catalyst__qis__Hadamard(%17, %4) : (!llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__qis__NamedObs(%3, %17) : (i64, !llvm.ptr) -> i64 - %20 = llvm.call @__catalyst__qis__Expval(%19) : (i64) -> f64 - %21 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %22 = llvm.ptrtoint %21 : !llvm.ptr to i64 - %23 = llvm.add %22, %1 : i64 - %24 = llvm.call @_mlir_memref_to_llvm_alloc(%23) : (i64) -> !llvm.ptr - %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 - %26 = llvm.sub %1, %2 : i64 - %27 = llvm.add %25, %26 : i64 - %28 = llvm.urem %27, %1 : i64 - %29 = llvm.sub %27, %28 : i64 - %30 = llvm.inttoptr %29 : i64 to !llvm.ptr - %31 = llvm.insertvalue %24, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %32 = llvm.insertvalue %30, %31[1] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %0, %32[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %20, %30 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %33 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @setup() { - %0 = llvm.mlir.zero : !llvm.ptr - llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @teardown() { - llvm.call @__catalyst__rt__finalize() : () -> () - llvm.return - } -} \ No newline at end of file diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/6_llvm_ir.ll b/test_cancel_inverses_lowering_transform_applied_workflow_2/6_llvm_ir.ll deleted file mode 100644 index c9dcdeca50..0000000000 --- a/test_cancel_inverses_lowering_transform_applied_workflow_2/6_llvm_ir.ll +++ /dev/null @@ -1,224 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" - -@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" -@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" -@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" - -declare void @__catalyst__rt__finalize() - -declare void @__catalyst__rt__initialize(ptr) - -declare void @__catalyst__qis__Hadamard(ptr, ptr) - -declare void @__catalyst__rt__device_release() - -declare void @__catalyst__rt__qubit_release_array(ptr) - -declare double @__catalyst__qis__Expval(i64) - -declare i64 @__catalyst__qis__NamedObs(i64, ptr) - -declare void @__catalyst__qis__RX(double, ptr, ptr) - -declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) - -declare ptr @__catalyst__rt__qubit_allocate_array(i64) - -declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) - -declare ptr @_mlir_memref_to_llvm_alloc(i64) - -define { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %0, ptr %1, i64 %2) { - %4 = call { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) - %5 = call { ptr, ptr, i64 } @g_0(ptr %0, ptr %1, i64 %2) - %6 = call { ptr, ptr, i64 } @h_0(ptr %0, ptr %1, i64 %2) - %7 = extractvalue { ptr, ptr, i64 } %4, 0 - %8 = ptrtoint ptr %7 to i64 - %9 = icmp eq i64 3735928559, %8 - br i1 %9, label %10, label %18 - -10: ; preds = %3 - %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %12 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 - %13 = insertvalue { ptr, ptr, i64 } %12, ptr %11, 1 - %14 = insertvalue { ptr, ptr, i64 } %13, i64 0, 2 - %15 = extractvalue { ptr, ptr, i64 } %4, 1 - %16 = extractvalue { ptr, ptr, i64 } %4, 2 - %17 = getelementptr inbounds double, ptr %15, i64 %16 - call void @llvm.memcpy.p0.p0.i64(ptr %11, ptr %17, i64 8, i1 false) - br label %19 - -18: ; preds = %3 - br label %19 - -19: ; preds = %10, %18 - %20 = phi { ptr, ptr, i64 } [ %4, %18 ], [ %14, %10 ] - br label %21 - -21: ; preds = %19 - %22 = extractvalue { ptr, ptr, i64 } %5, 0 - %23 = ptrtoint ptr %22 to i64 - %24 = icmp eq i64 3735928559, %23 - br i1 %24, label %25, label %33 - -25: ; preds = %21 - %26 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %27 = insertvalue { ptr, ptr, i64 } poison, ptr %26, 0 - %28 = insertvalue { ptr, ptr, i64 } %27, ptr %26, 1 - %29 = insertvalue { ptr, ptr, i64 } %28, i64 0, 2 - %30 = extractvalue { ptr, ptr, i64 } %5, 1 - %31 = extractvalue { ptr, ptr, i64 } %5, 2 - %32 = getelementptr inbounds double, ptr %30, i64 %31 - call void @llvm.memcpy.p0.p0.i64(ptr %26, ptr %32, i64 8, i1 false) - br label %34 - -33: ; preds = %21 - br label %34 - -34: ; preds = %25, %33 - %35 = phi { ptr, ptr, i64 } [ %5, %33 ], [ %29, %25 ] - br label %36 - -36: ; preds = %34 - %37 = extractvalue { ptr, ptr, i64 } %6, 0 - %38 = ptrtoint ptr %37 to i64 - %39 = icmp eq i64 3735928559, %38 - br i1 %39, label %40, label %48 - -40: ; preds = %36 - %41 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %42 = insertvalue { ptr, ptr, i64 } poison, ptr %41, 0 - %43 = insertvalue { ptr, ptr, i64 } %42, ptr %41, 1 - %44 = insertvalue { ptr, ptr, i64 } %43, i64 0, 2 - %45 = extractvalue { ptr, ptr, i64 } %6, 1 - %46 = extractvalue { ptr, ptr, i64 } %6, 2 - %47 = getelementptr inbounds double, ptr %45, i64 %46 - call void @llvm.memcpy.p0.p0.i64(ptr %41, ptr %47, i64 8, i1 false) - br label %49 - -48: ; preds = %36 - br label %49 - -49: ; preds = %40, %48 - %50 = phi { ptr, ptr, i64 } [ %6, %48 ], [ %44, %40 ] - br label %51 - -51: ; preds = %49 - %52 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %20, 0 - %53 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } %52, { ptr, ptr, i64 } %35, 1 - %54 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } %53, { ptr, ptr, i64 } %50, 2 - ret { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } %54 -} - -define void @_catalyst_pyface_jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %0, ptr %1) { - %3 = load { ptr, ptr }, ptr %1, align 8 - %4 = extractvalue { ptr, ptr } %3, 0 - call void @_catalyst_ciface_jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %0, ptr %4) - ret void -} - -define void @_catalyst_ciface_jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %0, ptr %1) { - %3 = load { ptr, ptr, i64 }, ptr %1, align 8 - %4 = extractvalue { ptr, ptr, i64 } %3, 0 - %5 = extractvalue { ptr, ptr, i64 } %3, 1 - %6 = extractvalue { ptr, ptr, i64 } %3, 2 - %7 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_cancel_inverses_lowering_transform_applied_workflow(ptr %4, ptr %5, i64 %6) - store { { ptr, ptr, i64 }, { ptr, ptr, i64 }, { ptr, ptr, i64 } } %7, ptr %0, align 8 - ret void -} - -define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) - %9 = call double @__catalyst__qis__Expval(i64 %8) - %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %11 = ptrtoint ptr %10 to i64 - %12 = add i64 %11, 63 - %13 = urem i64 %12, 64 - %14 = sub i64 %12, %13 - %15 = inttoptr i64 %14 to ptr - %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 - %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 - %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 - store double %9, ptr %15, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %18 -} - -define internal { ptr, ptr, i64 } @g_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - call void @__catalyst__qis__Hadamard(ptr %6, ptr null) - call void @__catalyst__qis__Hadamard(ptr %6, ptr null) - %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) - %9 = call double @__catalyst__qis__Expval(i64 %8) - %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %11 = ptrtoint ptr %10 to i64 - %12 = add i64 %11, 63 - %13 = urem i64 %12, 64 - %14 = sub i64 %12, %13 - %15 = inttoptr i64 %14 to ptr - %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 - %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 - %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 - store double %9, ptr %15, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %18 -} - -define internal { ptr, ptr, i64 } @h_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 1) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - call void @__catalyst__qis__Hadamard(ptr %6, ptr null) - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - call void @__catalyst__qis__Hadamard(ptr %6, ptr null) - %8 = call i64 @__catalyst__qis__NamedObs(i64 3, ptr %6) - %9 = call double @__catalyst__qis__Expval(i64 %8) - %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %11 = ptrtoint ptr %10 to i64 - %12 = add i64 %11, 63 - %13 = urem i64 %12, 64 - %14 = sub i64 %12, %13 - %15 = inttoptr i64 %14 to ptr - %16 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 - %17 = insertvalue { ptr, ptr, i64 } %16, ptr %15, 1 - %18 = insertvalue { ptr, ptr, i64 } %17, i64 0, 2 - store double %9, ptr %15, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %18 -} - -define void @setup() { - call void @__catalyst__rt__initialize(ptr null) - ret void -} - -define void @teardown() { - call void @__catalyst__rt__finalize() - ret void -} - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 - -attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_cancel_inverses_lowering_transform_applied_workflow_2/test_cancel_inverses_lowering_transform_applied_workflow.o b/test_cancel_inverses_lowering_transform_applied_workflow_2/test_cancel_inverses_lowering_transform_applied_workflow.o deleted file mode 100644 index a3c4fbadba8bff251326e562585e7c0ac11cff7a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4640 zcmdT{U2GIp6u#Rnu%%_YND&aUMNCSBWm|ZFh^reZLZpET7%>_z!|t>@bar-~owk(q zrwKgt!3QuVkcfr{9@;)(;)97MVuFb;#-FG$Mw2O2vs((NF_CM!)bGsP+3s!uqcIw9 z_Rcrw=brQ3b7$t>{q*;%Hyar9F*Lf=q6cblX+cL@fj;b59dXWOB;cyn(ik*PUVwY* z6ptF`mU_f;?_GKS_5=H8W$$ieo_j~}DCB1g8QV&#S~f)BHO}K{BRdgOqBPgCMfvkY*$GMv1-KLUK zJ-L$KFck-_#fw+x#>*pK2>N=)l8%GCYy>VxcirzPnJ6jglZzNzN%xK517aA@y3nbi zgifcDz|4^1FSnUvwVzL?L!-sq;?YaJOpM2wu%BfjzlR9~dp+-GWA?K#kKVIh7Q|6a0^UGq~0CMG+xbzBqzCZQF$XD!46#;94)8C)e-d#gVJk?R!(j<*%b;J0 zz5up*jB7;S4E-MHnvrKgOiXQ!iK}a3;#z%7Tz@nserk=0pBrPMeFYP3itgPM(fey-Vl|67&s8z^;Rxwx zj`=<>=H`vkvt|34sHuwy-#qyEP>(h2Bs~MRANSx>0FO!JzXJYK;C~hTuYv1za3pS_ z7A6{3F%ewO#G)o98bVCeH!!g7 ze&wIzs}@rP!jkHeTOuQdjU5j24O9ukfe>z-7?Fx*auy`vnSrlJ|yigx}#_duV~ZK{;{i_ zW4|ah_HFFvBjn%P=7(ivc4#%*2= zSZDBT&0D@VYu@mm@yVkngMt!| zU-4uRj|m|0z@A7L{SHVxzHu@7B@jb8KXWlU0wf;ifW%`6NIWt?;-LeH$8$i++X1A! zTY!{zJ&^LQ0#e@PE=HSxlsDvJv;jzY11?6-;=RJTGi(8I9u1$v8d6?5{}P_TniJ|k z3<-At;Topr5iVid#rYQ`o|QNx@u0+*#1@GF8b3dP3y#?L5eD(gLr*dxj?O`Pj!7m& z{@{p|3Be;cEM-Cpk(4qa<`dj0WkQ_2gT$NS5n|rKDGGvtUZd{}$=>(oHz|AHmtUmp zeNT3ij2=SKsXap^ApeA-Q=`x%d;fcWl>VM?at8#uXXj#s85z%gAlU!xJE5|x?cPa@b1u~T;O6V*g?@@8a(bbe{SUh8y zyq!E#x@Pi}nljaHZl$@d_hT7o;TivLj!PAfnKQ4w2bgZ9GMk+1M(5h@T-z8=a$I`o J(v6F3e*ncAp$7l} diff --git a/test_pipeline_lowering_keep_original_workflow_3/0_test_pipeline_lowering_keep_original_workflow.mlir b/test_pipeline_lowering_keep_original_workflow_3/0_test_pipeline_lowering_keep_original_workflow.mlir deleted file mode 100644 index 492a27222d..0000000000 --- a/test_pipeline_lowering_keep_original_workflow_3/0_test_pipeline_lowering_keep_original_workflow.mlir +++ /dev/null @@ -1,83 +0,0 @@ -module @test_pipeline_lowering_keep_original_workflow { - func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: tensor) -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %0 = catalyst.launch_kernel @module_f::@f(%arg0) : (tensor) -> tensor - %1 = catalyst.launch_kernel @module_f_0::@f_1(%arg0) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - module @module_f { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - transform.yield - } - } - func.func public @f(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<2> : tensor - %0 = quantum.alloc( 2) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %c_3 = stablehlo.constant dense<1> : tensor - %extracted_4 = tensor.extract %c_3[] : tensor - %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit - %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %extracted_7 = tensor.extract %c[] : tensor - %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit - %extracted_8 = tensor.extract %c_3[] : tensor - %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - module @module_f_0 { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @f_1(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<2> : tensor - %0 = quantum.alloc( 2) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %c_3 = stablehlo.constant dense<1> : tensor - %extracted_4 = tensor.extract %c_3[] : tensor - %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit - %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %extracted_7 = tensor.extract %c[] : tensor - %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit - %extracted_8 = tensor.extract %c_3[] : tensor - %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/1_EnforceRuntimeInvariantsPass.mlir b/test_pipeline_lowering_keep_original_workflow_3/1_EnforceRuntimeInvariantsPass.mlir deleted file mode 100644 index 3f9a41aaf9..0000000000 --- a/test_pipeline_lowering_keep_original_workflow_3/1_EnforceRuntimeInvariantsPass.mlir +++ /dev/null @@ -1,51 +0,0 @@ -module @test_pipeline_lowering_keep_original_workflow { - func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: tensor) -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %0 = call @f_0(%arg0) : (tensor) -> tensor - %1 = call @f_1_0(%arg0) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/2_HLOLoweringPass.mlir b/test_pipeline_lowering_keep_original_workflow_3/2_HLOLoweringPass.mlir deleted file mode 100644 index 3f9a41aaf9..0000000000 --- a/test_pipeline_lowering_keep_original_workflow_3/2_HLOLoweringPass.mlir +++ /dev/null @@ -1,51 +0,0 @@ -module @test_pipeline_lowering_keep_original_workflow { - func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: tensor) -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %0 = call @f_0(%arg0) : (tensor) -> tensor - %1 = call @f_1_0(%arg0) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/3_QuantumCompilationPass.mlir b/test_pipeline_lowering_keep_original_workflow_3/3_QuantumCompilationPass.mlir deleted file mode 100644 index 3f9a41aaf9..0000000000 --- a/test_pipeline_lowering_keep_original_workflow_3/3_QuantumCompilationPass.mlir +++ /dev/null @@ -1,51 +0,0 @@ -module @test_pipeline_lowering_keep_original_workflow { - func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: tensor) -> (tensor, tensor) attributes {llvm.emit_c_interface} { - %0 = call @f_0(%arg0) : (tensor) -> tensor - %1 = call @f_1_0(%arg0) : (tensor) -> tensor - return %0, %1 : tensor, tensor - } - func.func public @f_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func public @f_1_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/4_BufferizationPass.mlir b/test_pipeline_lowering_keep_original_workflow_3/4_BufferizationPass.mlir deleted file mode 100644 index 338b47cbc6..0000000000 --- a/test_pipeline_lowering_keep_original_workflow_3/4_BufferizationPass.mlir +++ /dev/null @@ -1,76 +0,0 @@ -module @test_pipeline_lowering_keep_original_workflow { - func.func public @jit_test_pipeline_lowering_keep_original_workflow(%arg0: memref) -> (memref, memref) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(3735928559 : index) : i64 - %1 = call @f_0(%arg0) : (memref) -> memref - %2 = call @f_1_0(%arg0) : (memref) -> memref - %3 = builtin.unrealized_conversion_cast %1 : memref to !llvm.struct<(ptr, ptr, i64)> - %4 = llvm.extractvalue %3[0] : !llvm.struct<(ptr, ptr, i64)> - %5 = llvm.ptrtoint %4 : !llvm.ptr to i64 - %6 = llvm.icmp "eq" %0, %5 : i64 - %7 = scf.if %6 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %1, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %1 : memref - } - %8 = builtin.unrealized_conversion_cast %2 : memref to !llvm.struct<(ptr, ptr, i64)> - %9 = llvm.extractvalue %8[0] : !llvm.struct<(ptr, ptr, i64)> - %10 = llvm.ptrtoint %9 : !llvm.ptr to i64 - %11 = llvm.icmp "eq" %0, %10 : i64 - %12 = scf.if %11 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %2, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %2 : memref - } - return %7, %12 : memref, memref - } - func.func public @f_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %out_qubits_0 = quantum.custom "Hadamard"() %3 : !quantum.bit - %out_qubits_1 = quantum.custom "Hadamard"() %out_qubits_0 : !quantum.bit - %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %5 = quantum.expval %4 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %5, %alloc[] : memref - %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %7 = quantum.insert %6[ 1], %out_qubits_1 : !quantum.reg, !quantum.bit - quantum.dealloc %7 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func public @f_1_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %5 = quantum.expval %4 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %5, %alloc[] : memref - %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit - quantum.dealloc %7 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/5_MLIRToLLVMDialect.mlir b/test_pipeline_lowering_keep_original_workflow_3/5_MLIRToLLVMDialect.mlir deleted file mode 100644 index 98d9fda263..0000000000 --- a/test_pipeline_lowering_keep_original_workflow_3/5_MLIRToLLVMDialect.mlir +++ /dev/null @@ -1,191 +0,0 @@ -module @test_pipeline_lowering_keep_original_workflow { - llvm.func @__catalyst__rt__finalize() - llvm.func @__catalyst__rt__initialize(!llvm.ptr) - llvm.func @__catalyst__rt__device_release() - llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) - llvm.func @__catalyst__qis__Expval(i64) -> f64 - llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 - llvm.func @__catalyst__qis__Hadamard(!llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr - llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr - llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} - llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) - llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr - llvm.func @jit_test_pipeline_lowering_keep_original_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.poison : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %1 = llvm.mlir.constant(0 : index) : i64 - %2 = llvm.mlir.zero : !llvm.ptr - %3 = llvm.mlir.constant(1 : index) : i64 - %4 = llvm.mlir.constant(3735928559 : index) : i64 - %5 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %6 = llvm.call @f_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %7 = llvm.call @f_1_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %8 = llvm.extractvalue %6[0] : !llvm.struct<(ptr, ptr, i64)> - %9 = llvm.ptrtoint %8 : !llvm.ptr to i64 - %10 = llvm.icmp "eq" %4, %9 : i64 - llvm.cond_br %10, ^bb1, ^bb2 - ^bb1: // pred: ^bb0 - %11 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %12 = llvm.ptrtoint %11 : !llvm.ptr to i64 - %13 = llvm.call @_mlir_memref_to_llvm_alloc(%12) : (i64) -> !llvm.ptr - %14 = llvm.insertvalue %13, %5[0] : !llvm.struct<(ptr, ptr, i64)> - %15 = llvm.insertvalue %13, %14[1] : !llvm.struct<(ptr, ptr, i64)> - %16 = llvm.insertvalue %1, %15[2] : !llvm.struct<(ptr, ptr, i64)> - %17 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %18 = llvm.ptrtoint %17 : !llvm.ptr to i64 - %19 = llvm.mul %18, %3 : i64 - %20 = llvm.extractvalue %6[1] : !llvm.struct<(ptr, ptr, i64)> - %21 = llvm.extractvalue %6[2] : !llvm.struct<(ptr, ptr, i64)> - %22 = llvm.getelementptr inbounds %20[%21] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%13, %22, %19) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb3(%16 : !llvm.struct<(ptr, ptr, i64)>) - ^bb2: // pred: ^bb0 - llvm.br ^bb3(%6 : !llvm.struct<(ptr, ptr, i64)>) - ^bb3(%23: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 - llvm.br ^bb4 - ^bb4: // pred: ^bb3 - %24 = llvm.extractvalue %7[0] : !llvm.struct<(ptr, ptr, i64)> - %25 = llvm.ptrtoint %24 : !llvm.ptr to i64 - %26 = llvm.icmp "eq" %4, %25 : i64 - llvm.cond_br %26, ^bb5, ^bb6 - ^bb5: // pred: ^bb4 - %27 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %28 = llvm.ptrtoint %27 : !llvm.ptr to i64 - %29 = llvm.call @_mlir_memref_to_llvm_alloc(%28) : (i64) -> !llvm.ptr - %30 = llvm.insertvalue %29, %5[0] : !llvm.struct<(ptr, ptr, i64)> - %31 = llvm.insertvalue %29, %30[1] : !llvm.struct<(ptr, ptr, i64)> - %32 = llvm.insertvalue %1, %31[2] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.getelementptr %2[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %34 = llvm.ptrtoint %33 : !llvm.ptr to i64 - %35 = llvm.mul %34, %3 : i64 - %36 = llvm.extractvalue %7[1] : !llvm.struct<(ptr, ptr, i64)> - %37 = llvm.extractvalue %7[2] : !llvm.struct<(ptr, ptr, i64)> - %38 = llvm.getelementptr inbounds %36[%37] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%29, %38, %35) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb7(%32 : !llvm.struct<(ptr, ptr, i64)>) - ^bb6: // pred: ^bb4 - llvm.br ^bb7(%7 : !llvm.struct<(ptr, ptr, i64)>) - ^bb7(%39: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb5, ^bb6 - llvm.br ^bb8 - ^bb8: // pred: ^bb7 - %40 = llvm.insertvalue %23, %0[0] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - %41 = llvm.insertvalue %39, %40[1] : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.return %41 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - } - llvm.func @_catalyst_pyface_jit_test_pipeline_lowering_keep_original_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { - %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr)> - %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr)> - llvm.call @_catalyst_ciface_jit_test_pipeline_lowering_keep_original_workflow(%arg0, %1) : (!llvm.ptr, !llvm.ptr) -> () - llvm.return - } - llvm.func @_catalyst_ciface_jit_test_pipeline_lowering_keep_original_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr, i64)> - %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr, i64)> - %2 = llvm.extractvalue %0[1] : !llvm.struct<(ptr, ptr, i64)> - %3 = llvm.extractvalue %0[2] : !llvm.struct<(ptr, ptr, i64)> - %4 = llvm.call @jit_test_pipeline_lowering_keep_original_workflow(%1, %2, %3) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)> - llvm.store %4, %arg0 : !llvm.struct<(struct<(ptr, ptr, i64)>, struct<(ptr, ptr, i64)>)>, !llvm.ptr - llvm.return - } - llvm.func internal @f_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(1 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(2 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr - %20 = llvm.load %19 : !llvm.ptr -> !llvm.ptr - llvm.call @__catalyst__qis__Hadamard(%20, %4) : (!llvm.ptr, !llvm.ptr) -> () - llvm.call @__catalyst__qis__Hadamard(%20, %4) : (!llvm.ptr, !llvm.ptr) -> () - %21 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 - %22 = llvm.call @__catalyst__qis__Expval(%21) : (i64) -> f64 - %23 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %24 = llvm.ptrtoint %23 : !llvm.ptr to i64 - %25 = llvm.add %24, %1 : i64 - %26 = llvm.call @_mlir_memref_to_llvm_alloc(%25) : (i64) -> !llvm.ptr - %27 = llvm.ptrtoint %26 : !llvm.ptr to i64 - %28 = llvm.sub %1, %2 : i64 - %29 = llvm.add %27, %28 : i64 - %30 = llvm.urem %29, %1 : i64 - %31 = llvm.sub %29, %30 : i64 - %32 = llvm.inttoptr %31 : i64 to !llvm.ptr - %33 = llvm.insertvalue %26, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %32, %33[1] : !llvm.struct<(ptr, ptr, i64)> - %35 = llvm.insertvalue %0, %34[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %22, %32 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %35 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func internal @f_1_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(1 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(2 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr - %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 - %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 - %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 - %24 = llvm.add %23, %1 : i64 - %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr - %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 - %27 = llvm.sub %1, %2 : i64 - %28 = llvm.add %26, %27 : i64 - %29 = llvm.urem %28, %1 : i64 - %30 = llvm.sub %28, %29 : i64 - %31 = llvm.inttoptr %30 : i64 to !llvm.ptr - %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %21, %31 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @setup() { - %0 = llvm.mlir.zero : !llvm.ptr - llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @teardown() { - llvm.call @__catalyst__rt__finalize() : () -> () - llvm.return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_keep_original_workflow_3/6_llvm_ir.ll b/test_pipeline_lowering_keep_original_workflow_3/6_llvm_ir.ll deleted file mode 100644 index fa3cd5d3bf..0000000000 --- a/test_pipeline_lowering_keep_original_workflow_3/6_llvm_ir.ll +++ /dev/null @@ -1,175 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" - -@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" -@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" -@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" - -declare void @__catalyst__rt__finalize() - -declare void @__catalyst__rt__initialize(ptr) - -declare void @__catalyst__rt__device_release() - -declare void @__catalyst__rt__qubit_release_array(ptr) - -declare double @__catalyst__qis__Expval(i64) - -declare i64 @__catalyst__qis__NamedObs(i64, ptr) - -declare void @__catalyst__qis__Hadamard(ptr, ptr) - -declare void @__catalyst__qis__RX(double, ptr, ptr) - -declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) - -declare ptr @__catalyst__rt__qubit_allocate_array(i64) - -declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) - -declare ptr @_mlir_memref_to_llvm_alloc(i64) - -define { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_pipeline_lowering_keep_original_workflow(ptr %0, ptr %1, i64 %2) { - %4 = call { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) - %5 = call { ptr, ptr, i64 } @f_1_0(ptr %0, ptr %1, i64 %2) - %6 = extractvalue { ptr, ptr, i64 } %4, 0 - %7 = ptrtoint ptr %6 to i64 - %8 = icmp eq i64 3735928559, %7 - br i1 %8, label %9, label %17 - -9: ; preds = %3 - %10 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %11 = insertvalue { ptr, ptr, i64 } poison, ptr %10, 0 - %12 = insertvalue { ptr, ptr, i64 } %11, ptr %10, 1 - %13 = insertvalue { ptr, ptr, i64 } %12, i64 0, 2 - %14 = extractvalue { ptr, ptr, i64 } %4, 1 - %15 = extractvalue { ptr, ptr, i64 } %4, 2 - %16 = getelementptr inbounds double, ptr %14, i64 %15 - call void @llvm.memcpy.p0.p0.i64(ptr %10, ptr %16, i64 8, i1 false) - br label %18 - -17: ; preds = %3 - br label %18 - -18: ; preds = %9, %17 - %19 = phi { ptr, ptr, i64 } [ %4, %17 ], [ %13, %9 ] - br label %20 - -20: ; preds = %18 - %21 = extractvalue { ptr, ptr, i64 } %5, 0 - %22 = ptrtoint ptr %21 to i64 - %23 = icmp eq i64 3735928559, %22 - br i1 %23, label %24, label %32 - -24: ; preds = %20 - %25 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %26 = insertvalue { ptr, ptr, i64 } poison, ptr %25, 0 - %27 = insertvalue { ptr, ptr, i64 } %26, ptr %25, 1 - %28 = insertvalue { ptr, ptr, i64 } %27, i64 0, 2 - %29 = extractvalue { ptr, ptr, i64 } %5, 1 - %30 = extractvalue { ptr, ptr, i64 } %5, 2 - %31 = getelementptr inbounds double, ptr %29, i64 %30 - call void @llvm.memcpy.p0.p0.i64(ptr %25, ptr %31, i64 8, i1 false) - br label %33 - -32: ; preds = %20 - br label %33 - -33: ; preds = %24, %32 - %34 = phi { ptr, ptr, i64 } [ %5, %32 ], [ %28, %24 ] - br label %35 - -35: ; preds = %33 - %36 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } poison, { ptr, ptr, i64 } %19, 0 - %37 = insertvalue { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %36, { ptr, ptr, i64 } %34, 1 - ret { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %37 -} - -define void @_catalyst_pyface_jit_test_pipeline_lowering_keep_original_workflow(ptr %0, ptr %1) { - %3 = load { ptr, ptr }, ptr %1, align 8 - %4 = extractvalue { ptr, ptr } %3, 0 - call void @_catalyst_ciface_jit_test_pipeline_lowering_keep_original_workflow(ptr %0, ptr %4) - ret void -} - -define void @_catalyst_ciface_jit_test_pipeline_lowering_keep_original_workflow(ptr %0, ptr %1) { - %3 = load { ptr, ptr, i64 }, ptr %1, align 8 - %4 = extractvalue { ptr, ptr, i64 } %3, 0 - %5 = extractvalue { ptr, ptr, i64 } %3, 1 - %6 = extractvalue { ptr, ptr, i64 } %3, 2 - %7 = call { { ptr, ptr, i64 }, { ptr, ptr, i64 } } @jit_test_pipeline_lowering_keep_original_workflow(ptr %4, ptr %5, i64 %6) - store { { ptr, ptr, i64 }, { ptr, ptr, i64 } } %7, ptr %0, align 8 - ret void -} - -define internal { ptr, ptr, i64 } @f_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) - %9 = load ptr, ptr %8, align 8 - call void @__catalyst__qis__Hadamard(ptr %9, ptr null) - call void @__catalyst__qis__Hadamard(ptr %9, ptr null) - %10 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) - %11 = call double @__catalyst__qis__Expval(i64 %10) - %12 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %13 = ptrtoint ptr %12 to i64 - %14 = add i64 %13, 63 - %15 = urem i64 %14, 64 - %16 = sub i64 %14, %15 - %17 = inttoptr i64 %16 to ptr - %18 = insertvalue { ptr, ptr, i64 } poison, ptr %12, 0 - %19 = insertvalue { ptr, ptr, i64 } %18, ptr %17, 1 - %20 = insertvalue { ptr, ptr, i64 } %19, i64 0, 2 - store double %11, ptr %17, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %20 -} - -define internal { ptr, ptr, i64 } @f_1_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) - %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) - %10 = call double @__catalyst__qis__Expval(i64 %9) - %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %12 = ptrtoint ptr %11 to i64 - %13 = add i64 %12, 63 - %14 = urem i64 %13, 64 - %15 = sub i64 %13, %14 - %16 = inttoptr i64 %15 to ptr - %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 - %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 - %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 - store double %10, ptr %16, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %19 -} - -define void @setup() { - call void @__catalyst__rt__initialize(ptr null) - ret void -} - -define void @teardown() { - call void @__catalyst__rt__finalize() - ret void -} - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 - -attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_pipeline_lowering_keep_original_workflow_3/test_pipeline_lowering_keep_original_workflow.o b/test_pipeline_lowering_keep_original_workflow_3/test_pipeline_lowering_keep_original_workflow.o deleted file mode 100644 index 48c67b01a773d9b0d391b24baff81102b9e4a9b3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3880 zcmc&%T}%{L6u!fPE}{!oEwvKC`T(h27o>@%N}LvKNhC^?Mjsk4!*YR<+1Yh=_;YPS z;|mWyXk*fc{=`R?m-5i04>c)Gnlx#e)HbQ@gH3i3leM*pF+MO&xAZ$Rcb44+n$(xx zaOb<{e&?Kf&bfE?4&VRz$KP8SQy3aOD$#=#cr>A-?M9z*Syx>1nBL?~wU7;(FK@<} zI{BlT#WD`ON$9# zE{$&n@lad#fX$;=8`y13k;!2SUIM3|FlXAX|Y&J6Uk&|kzF#T@FjGjjl31oQ3ajj-DfyJqG* zJdHI9F;uUO;T-t0{}RIv_^OAmJu(L9XQ96czl%kj8^aE8^_bs-z8Q8ku&ZUxgUzb5 zRHHigYcbylo&73eQ=NS3WEwTUu@K;Q^QkY>FIB3}KBl@g&!@hcrTLYs411!asqPv0 ztf*EUr3yNVr<8+XPraUoz3YGFsscY%=`4Jp_SeyGAm;1) zfH+Fm-vHjn9^7wc&QhS!-Jfpe?G@!f`;|q^R0kTT}yE#)G{hX0QNzSNE26-0p zsx8Z_R^|n}9L`oDFRE>EUN}oxI!jnHpXy4lbb5KwS)uoZ{QKvG=89#ES*ke}jYXSZ zYkE^NlH!%7W^*jY2gWQ@H!<0YiBVyh!r&%;!Z33xZi;uwP_`a@c*KVC@L4@JW@vWY z@)-{!ZzqM7j6_E)J!$Kv7U{L(!;z?FYsOU4=E5A082UgYF=da$&Gv(BhaySc7GeAX zk7~mr8A%A!oH8_1aKm4T3_bx7ZBU76XN4iTx5)iA@p#WVa~; z#C^M$a2rxxkTM~@D?+!VOo;VD(^4jceW+i`gorbwN||sA^=}d##fegSYn*CfMsMt-k-1N&My@qZ_- zO4)zs=-dLCVyTgzgH%ISSBAq zB$z6+3uQ8$(_)_SXS+!_KDhnMfLk_~zvr4^#4#_pW?9-4{%crQ%MymrlB-GuPl>4^ zEh_j$+zhtBHIvX2!qDjwiBAX%w-p~1BEjR9K8!ob;1h9cbO;<4D)@-%&+KE>iJQ`( z7}pVvZt8YvCYSUi=cjP74xS!JGQQ4T%9Fw#OE6@iS%dKja~=B=lZkQ7C?%+nLzJ0* zS*&F!5Pbtq#wsgYYU_sEtqp211XD`Ug6>xFVS!uS5HVq*?6$?*NHb>W7LSRTC5E^i r=Y}yJlQY;&Kjj1O`5(FXVj%kHqS diff --git a/test_pipeline_lowering_workflow_5/0_test_pipeline_lowering_workflow.mlir b/test_pipeline_lowering_workflow_5/0_test_pipeline_lowering_workflow.mlir deleted file mode 100644 index e31c55269d..0000000000 --- a/test_pipeline_lowering_workflow_5/0_test_pipeline_lowering_workflow.mlir +++ /dev/null @@ -1,49 +0,0 @@ -module @test_pipeline_lowering_workflow { - func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { - %0 = catalyst.launch_kernel @module_test_pipeline_lowering_workflow::@test_pipeline_lowering_workflow(%arg0) : (tensor) -> tensor - return %0 : tensor - } - module @module_test_pipeline_lowering_workflow { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<2> : tensor - %0 = quantum.alloc( 2) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %c_3 = stablehlo.constant dense<1> : tensor - %extracted_4 = tensor.extract %c_3[] : tensor - %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit - %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %extracted_7 = tensor.extract %c[] : tensor - %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit - %extracted_8 = tensor.extract %c_3[] : tensor - %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/1_EnforceRuntimeInvariantsPass.mlir b/test_pipeline_lowering_workflow_5/1_EnforceRuntimeInvariantsPass.mlir deleted file mode 100644 index 8f33d0a2b3..0000000000 --- a/test_pipeline_lowering_workflow_5/1_EnforceRuntimeInvariantsPass.mlir +++ /dev/null @@ -1,31 +0,0 @@ -module @test_pipeline_lowering_workflow { - func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { - %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor - return %0 : tensor - } - func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/2_HLOLoweringPass.mlir b/test_pipeline_lowering_workflow_5/2_HLOLoweringPass.mlir deleted file mode 100644 index 8f33d0a2b3..0000000000 --- a/test_pipeline_lowering_workflow_5/2_HLOLoweringPass.mlir +++ /dev/null @@ -1,31 +0,0 @@ -module @test_pipeline_lowering_workflow { - func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { - %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor - return %0 : tensor - } - func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/3_QuantumCompilationPass.mlir b/test_pipeline_lowering_workflow_5/3_QuantumCompilationPass.mlir deleted file mode 100644 index 8f33d0a2b3..0000000000 --- a/test_pipeline_lowering_workflow_5/3_QuantumCompilationPass.mlir +++ /dev/null @@ -1,31 +0,0 @@ -module @test_pipeline_lowering_workflow { - func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { - %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor - return %0 : tensor - } - func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/4_BufferizationPass.mlir b/test_pipeline_lowering_workflow_5/4_BufferizationPass.mlir deleted file mode 100644 index 1f2d2c8f7f..0000000000 --- a/test_pipeline_lowering_workflow_5/4_BufferizationPass.mlir +++ /dev/null @@ -1,44 +0,0 @@ -module @test_pipeline_lowering_workflow { - func.func public @jit_test_pipeline_lowering_workflow(%arg0: memref) -> memref attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(3735928559 : index) : i64 - %1 = call @test_pipeline_lowering_workflow_0(%arg0) : (memref) -> memref - %2 = builtin.unrealized_conversion_cast %1 : memref to !llvm.struct<(ptr, ptr, i64)> - %3 = llvm.extractvalue %2[0] : !llvm.struct<(ptr, ptr, i64)> - %4 = llvm.ptrtoint %3 : !llvm.ptr to i64 - %5 = llvm.icmp "eq" %0, %4 : i64 - %6 = scf.if %5 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %1, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %1 : memref - } - return %6 : memref - } - func.func public @test_pipeline_lowering_workflow_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %5 = quantum.expval %4 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %5, %alloc[] : memref - %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit - quantum.dealloc %7 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/5_MLIRToLLVMDialect.mlir b/test_pipeline_lowering_workflow_5/5_MLIRToLLVMDialect.mlir deleted file mode 100644 index beb525fb8a..0000000000 --- a/test_pipeline_lowering_workflow_5/5_MLIRToLLVMDialect.mlir +++ /dev/null @@ -1,116 +0,0 @@ -module @test_pipeline_lowering_workflow { - llvm.func @__catalyst__rt__finalize() - llvm.func @__catalyst__rt__initialize(!llvm.ptr) - llvm.func @__catalyst__rt__device_release() - llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) - llvm.func @__catalyst__qis__Expval(i64) -> f64 - llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 - llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr - llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr - llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} - llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) - llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr - llvm.func @jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.zero : !llvm.ptr - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(3735928559 : index) : i64 - %4 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %5 = llvm.call @test_pipeline_lowering_workflow_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %6 = llvm.extractvalue %5[0] : !llvm.struct<(ptr, ptr, i64)> - %7 = llvm.ptrtoint %6 : !llvm.ptr to i64 - %8 = llvm.icmp "eq" %3, %7 : i64 - llvm.cond_br %8, ^bb1, ^bb2 - ^bb1: // pred: ^bb0 - %9 = llvm.getelementptr %1[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %10 = llvm.ptrtoint %9 : !llvm.ptr to i64 - %11 = llvm.call @_mlir_memref_to_llvm_alloc(%10) : (i64) -> !llvm.ptr - %12 = llvm.insertvalue %11, %4[0] : !llvm.struct<(ptr, ptr, i64)> - %13 = llvm.insertvalue %11, %12[1] : !llvm.struct<(ptr, ptr, i64)> - %14 = llvm.insertvalue %0, %13[2] : !llvm.struct<(ptr, ptr, i64)> - %15 = llvm.getelementptr %1[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %16 = llvm.ptrtoint %15 : !llvm.ptr to i64 - %17 = llvm.mul %16, %2 : i64 - %18 = llvm.extractvalue %5[1] : !llvm.struct<(ptr, ptr, i64)> - %19 = llvm.extractvalue %5[2] : !llvm.struct<(ptr, ptr, i64)> - %20 = llvm.getelementptr inbounds %18[%19] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%11, %20, %17) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb3(%14 : !llvm.struct<(ptr, ptr, i64)>) - ^bb2: // pred: ^bb0 - llvm.br ^bb3(%5 : !llvm.struct<(ptr, ptr, i64)>) - ^bb3(%21: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 - llvm.br ^bb4 - ^bb4: // pred: ^bb3 - llvm.return %21 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @_catalyst_pyface_jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { - %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr)> - %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr)> - llvm.call @_catalyst_ciface_jit_test_pipeline_lowering_workflow(%arg0, %1) : (!llvm.ptr, !llvm.ptr) -> () - llvm.return - } - llvm.func @_catalyst_ciface_jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr, i64)> - %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr, i64)> - %2 = llvm.extractvalue %0[1] : !llvm.struct<(ptr, ptr, i64)> - %3 = llvm.extractvalue %0[2] : !llvm.struct<(ptr, ptr, i64)> - %4 = llvm.call @jit_test_pipeline_lowering_workflow(%1, %2, %3) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - llvm.store %4, %arg0 : !llvm.struct<(ptr, ptr, i64)>, !llvm.ptr - llvm.return - } - llvm.func internal @test_pipeline_lowering_workflow_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(1 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(2 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr - %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 - %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 - %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 - %24 = llvm.add %23, %1 : i64 - %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr - %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 - %27 = llvm.sub %1, %2 : i64 - %28 = llvm.add %26, %27 : i64 - %29 = llvm.urem %28, %1 : i64 - %30 = llvm.sub %28, %29 : i64 - %31 = llvm.inttoptr %30 : i64 to !llvm.ptr - %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %21, %31 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @setup() { - %0 = llvm.mlir.zero : !llvm.ptr - llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @teardown() { - llvm.call @__catalyst__rt__finalize() : () -> () - llvm.return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_5/6_llvm_ir.ll b/test_pipeline_lowering_workflow_5/6_llvm_ir.ll deleted file mode 100644 index c5b40ab21d..0000000000 --- a/test_pipeline_lowering_workflow_5/6_llvm_ir.ll +++ /dev/null @@ -1,118 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" - -@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" -@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" -@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" - -declare void @__catalyst__rt__finalize() - -declare void @__catalyst__rt__initialize(ptr) - -declare void @__catalyst__rt__device_release() - -declare void @__catalyst__rt__qubit_release_array(ptr) - -declare double @__catalyst__qis__Expval(i64) - -declare i64 @__catalyst__qis__NamedObs(i64, ptr) - -declare void @__catalyst__qis__RX(double, ptr, ptr) - -declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) - -declare ptr @__catalyst__rt__qubit_allocate_array(i64) - -declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) - -declare ptr @_mlir_memref_to_llvm_alloc(i64) - -define { ptr, ptr, i64 } @jit_test_pipeline_lowering_workflow(ptr %0, ptr %1, i64 %2) { - %4 = call { ptr, ptr, i64 } @test_pipeline_lowering_workflow_0(ptr %0, ptr %1, i64 %2) - %5 = extractvalue { ptr, ptr, i64 } %4, 0 - %6 = ptrtoint ptr %5 to i64 - %7 = icmp eq i64 3735928559, %6 - br i1 %7, label %8, label %16 - -8: ; preds = %3 - %9 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %10 = insertvalue { ptr, ptr, i64 } poison, ptr %9, 0 - %11 = insertvalue { ptr, ptr, i64 } %10, ptr %9, 1 - %12 = insertvalue { ptr, ptr, i64 } %11, i64 0, 2 - %13 = extractvalue { ptr, ptr, i64 } %4, 1 - %14 = extractvalue { ptr, ptr, i64 } %4, 2 - %15 = getelementptr inbounds double, ptr %13, i64 %14 - call void @llvm.memcpy.p0.p0.i64(ptr %9, ptr %15, i64 8, i1 false) - br label %17 - -16: ; preds = %3 - br label %17 - -17: ; preds = %8, %16 - %18 = phi { ptr, ptr, i64 } [ %4, %16 ], [ %12, %8 ] - br label %19 - -19: ; preds = %17 - ret { ptr, ptr, i64 } %18 -} - -define void @_catalyst_pyface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %1) { - %3 = load { ptr, ptr }, ptr %1, align 8 - %4 = extractvalue { ptr, ptr } %3, 0 - call void @_catalyst_ciface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %4) - ret void -} - -define void @_catalyst_ciface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %1) { - %3 = load { ptr, ptr, i64 }, ptr %1, align 8 - %4 = extractvalue { ptr, ptr, i64 } %3, 0 - %5 = extractvalue { ptr, ptr, i64 } %3, 1 - %6 = extractvalue { ptr, ptr, i64 } %3, 2 - %7 = call { ptr, ptr, i64 } @jit_test_pipeline_lowering_workflow(ptr %4, ptr %5, i64 %6) - store { ptr, ptr, i64 } %7, ptr %0, align 8 - ret void -} - -define internal { ptr, ptr, i64 } @test_pipeline_lowering_workflow_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) - %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) - %10 = call double @__catalyst__qis__Expval(i64 %9) - %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %12 = ptrtoint ptr %11 to i64 - %13 = add i64 %12, 63 - %14 = urem i64 %13, 64 - %15 = sub i64 %13, %14 - %16 = inttoptr i64 %15 to ptr - %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 - %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 - %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 - store double %10, ptr %16, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %19 -} - -define void @setup() { - call void @__catalyst__rt__initialize(ptr null) - ret void -} - -define void @teardown() { - call void @__catalyst__rt__finalize() - ret void -} - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 - -attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_pipeline_lowering_workflow_5/test_pipeline_lowering_workflow.o b/test_pipeline_lowering_workflow_5/test_pipeline_lowering_workflow.o deleted file mode 100644 index caced91192178fff3af454d907c7de877128823c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3104 zcmc&$T}&KR6h6ZOT?7}jXsd0?)|x8smd&vf_7U?uBJ3CiTUWz4OgE z-#O==duHa|{raz8{%#>M2*Q_ojBp(;Q4GjK7;pNlukO2KH~`YcF%YdE!aWZ~lMtSq z^VlO0A%@S73~Q|lRUXdAx2ugr4>Da(iws(XNT!|aZo+-}RGu3upbLfQT6B(Tc`GMWRF&oYA#lt%kPs;X9#4(OE5pBSTcpAiD39ErA=w1xw?pC&!jBhFn z4SB@9Tj-#2@f4MBc2c?Y!+YOe{qEZD9R~eu)X{L*SR5*Z!jG}vPo0T!=~SZpV~ExY zp^mj;sA=scMmTrz&n^S;hmq$9l?%tHj2hbu@GrvuW(P(Uhc&ks4ud-a`!S3|h-*e% zE8!mY<^=8&<;ueOJnCFo4~ZLss%F#^95^3^pFYy=x2=d;L3e$MUZxCiz5Vh9}3GR6vOTRsUy%a_jqZ(*Ic(4VbP zhu?#K3i?q%yr(7%RS&kVWbkmdZr0JP7Fz3tmVlV zzSv9Vq|C-M(s6RO=}2MgnK)oa5tpaOEKlf!r^j<(t4jDRxL050E}`uHw*~7yenYuF zb3lB3@WJZud|&+cif=z4{x`+99l$F)8S_JA%$+dWS~@5SU)~G0wgb^?p#I3{$Hqr^ zRf&#caLwz=hy8u&i?p#1^DkpuQ9S$l(jSRx{#6(j6~C!y%rU6>4`CZsyjmYoRsQSX z6N=aC(EJ}*_hF*g77($qb>RKL>p+|bu~py^AfHXx(_(J`BfvQza>b^At-wL0_W>V( z{sizo;G;mC2LsUndyfP0a0ZSB*xL?7qXyan?A=1G_aKgI#$FZc2J-y8x56cMCBVi- zg`)}+3Zn`E?BBQ!#Fl-65&M1QiqaXeKSvgo&Itd=sL~lRXC$F?Mr`?!<4R{losmya zd<217K2>_XvSF{L2*xM|OD9i)`-IZjjdgAU%lp7;{TH7U2fR5jewAAQxn7^98R>S{_$ZGzB8eZ1uuh-~L z*2KS3qu;LaC-L8QOo2ZldealGC)B=W+IAXtDNNTjbNDxPM=w{}(#-BU?PSX2Cd{N1 z7qJ6+65DCU%1GPd%`!bJUF^zYHtk-TfQHmNQAz7AqISdlvd86&g&8f!^7dAH*~$uW z0f)r+3u9RlcQ_YBR(jJJLZzlVo}P8?5PyCyGh^C&32xQ|P7d3em-`tm#5#aewW{vz zkM(;lCMAv`Tc)Ig{&}wG8HZ=ewp@{tDOXMiFD-0)CMEo5MdJTC(e}I(F-Q41TeHlbI{R8t>zFz) -> tensor attributes {llvm.emit_c_interface} { - %0 = catalyst.launch_kernel @module_test_pipeline_lowering_workflow::@test_pipeline_lowering_workflow(%arg0) : (tensor) -> tensor - return %0 : tensor - } - module @module_test_pipeline_lowering_workflow { - module attributes {transform.with_named_sequence} { - transform.named_sequence @__transform_main(%arg0: !transform.op<"builtin.module">) { - %0 = transform.apply_registered_pass "cancel-inverses" to %arg0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - %1 = transform.apply_registered_pass "merge-rotations" to %0 : (!transform.op<"builtin.module">) -> !transform.op<"builtin.module"> - transform.yield - } - } - func.func public @test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c = stablehlo.constant dense<0> : tensor - %extracted = tensor.extract %c[] : tensor - quantum.device shots(%extracted) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %c_0 = stablehlo.constant dense<2> : tensor - %0 = quantum.alloc( 2) : !quantum.reg - %extracted_1 = tensor.extract %c[] : tensor - %1 = quantum.extract %0[%extracted_1] : !quantum.reg -> !quantum.bit - %extracted_2 = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted_2) %1 : !quantum.bit - %c_3 = stablehlo.constant dense<1> : tensor - %extracted_4 = tensor.extract %c_3[] : tensor - %2 = quantum.extract %0[%extracted_4] : !quantum.reg -> !quantum.bit - %out_qubits_5 = quantum.custom "Hadamard"() %2 : !quantum.bit - %out_qubits_6 = quantum.custom "Hadamard"() %out_qubits_5 : !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %extracted_7 = tensor.extract %c[] : tensor - %5 = quantum.insert %0[%extracted_7], %out_qubits : !quantum.reg, !quantum.bit - %extracted_8 = tensor.extract %c_3[] : tensor - %6 = quantum.insert %5[%extracted_8], %out_qubits_6 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/1_EnforceRuntimeInvariantsPass.mlir b/test_pipeline_lowering_workflow_6/1_EnforceRuntimeInvariantsPass.mlir deleted file mode 100644 index 8f33d0a2b3..0000000000 --- a/test_pipeline_lowering_workflow_6/1_EnforceRuntimeInvariantsPass.mlir +++ /dev/null @@ -1,31 +0,0 @@ -module @test_pipeline_lowering_workflow { - func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { - %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor - return %0 : tensor - } - func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/2_HLOLoweringPass.mlir b/test_pipeline_lowering_workflow_6/2_HLOLoweringPass.mlir deleted file mode 100644 index 8f33d0a2b3..0000000000 --- a/test_pipeline_lowering_workflow_6/2_HLOLoweringPass.mlir +++ /dev/null @@ -1,31 +0,0 @@ -module @test_pipeline_lowering_workflow { - func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { - %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor - return %0 : tensor - } - func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/3_QuantumCompilationPass.mlir b/test_pipeline_lowering_workflow_6/3_QuantumCompilationPass.mlir deleted file mode 100644 index 8f33d0a2b3..0000000000 --- a/test_pipeline_lowering_workflow_6/3_QuantumCompilationPass.mlir +++ /dev/null @@ -1,31 +0,0 @@ -module @test_pipeline_lowering_workflow { - func.func public @jit_test_pipeline_lowering_workflow(%arg0: tensor) -> tensor attributes {llvm.emit_c_interface} { - %0 = call @test_pipeline_lowering_workflow_0(%arg0) : (tensor) -> tensor - return %0 : tensor - } - func.func public @test_pipeline_lowering_workflow_0(%arg0: tensor) -> tensor attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %extracted = tensor.extract %arg0[] : tensor - %out_qubits = quantum.custom "RX"(%extracted) %1 : !quantum.bit - %2 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %3 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %4 = quantum.expval %3 : f64 - %from_elements = tensor.from_elements %4 : tensor - %5 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %6 = quantum.insert %5[ 1], %2 : !quantum.reg, !quantum.bit - quantum.dealloc %6 : !quantum.reg - quantum.device_release - return %from_elements : tensor - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/4_BufferizationPass.mlir b/test_pipeline_lowering_workflow_6/4_BufferizationPass.mlir deleted file mode 100644 index 1f2d2c8f7f..0000000000 --- a/test_pipeline_lowering_workflow_6/4_BufferizationPass.mlir +++ /dev/null @@ -1,44 +0,0 @@ -module @test_pipeline_lowering_workflow { - func.func public @jit_test_pipeline_lowering_workflow(%arg0: memref) -> memref attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(3735928559 : index) : i64 - %1 = call @test_pipeline_lowering_workflow_0(%arg0) : (memref) -> memref - %2 = builtin.unrealized_conversion_cast %1 : memref to !llvm.struct<(ptr, ptr, i64)> - %3 = llvm.extractvalue %2[0] : !llvm.struct<(ptr, ptr, i64)> - %4 = llvm.ptrtoint %3 : !llvm.ptr to i64 - %5 = llvm.icmp "eq" %0, %4 : i64 - %6 = scf.if %5 -> (memref) { - %alloc = memref.alloc() : memref - memref.copy %1, %alloc : memref to memref - scf.yield %alloc : memref - } else { - scf.yield %1 : memref - } - return %6 : memref - } - func.func public @test_pipeline_lowering_workflow_0(%arg0: memref) -> memref attributes {diff_method = "adjoint", llvm.linkage = #llvm.linkage, qnode} { - %c0_i64 = arith.constant 0 : i64 - quantum.device shots(%c0_i64) ["/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", "LightningSimulator", "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] - %0 = quantum.alloc( 2) : !quantum.reg - %1 = quantum.extract %0[ 0] : !quantum.reg -> !quantum.bit - %2 = memref.load %arg0[] : memref - %out_qubits = quantum.custom "RX"(%2) %1 : !quantum.bit - %3 = quantum.extract %0[ 1] : !quantum.reg -> !quantum.bit - %4 = quantum.namedobs %out_qubits[ PauliY] : !quantum.obs - %5 = quantum.expval %4 : f64 - %alloc = memref.alloc() {alignment = 64 : i64} : memref - memref.store %5, %alloc[] : memref - %6 = quantum.insert %0[ 0], %out_qubits : !quantum.reg, !quantum.bit - %7 = quantum.insert %6[ 1], %3 : !quantum.reg, !quantum.bit - quantum.dealloc %7 : !quantum.reg - quantum.device_release - return %alloc : memref - } - func.func @setup() { - quantum.init - return - } - func.func @teardown() { - quantum.finalize - return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/5_MLIRToLLVMDialect.mlir b/test_pipeline_lowering_workflow_6/5_MLIRToLLVMDialect.mlir deleted file mode 100644 index beb525fb8a..0000000000 --- a/test_pipeline_lowering_workflow_6/5_MLIRToLLVMDialect.mlir +++ /dev/null @@ -1,116 +0,0 @@ -module @test_pipeline_lowering_workflow { - llvm.func @__catalyst__rt__finalize() - llvm.func @__catalyst__rt__initialize(!llvm.ptr) - llvm.func @__catalyst__rt__device_release() - llvm.func @__catalyst__rt__qubit_release_array(!llvm.ptr) - llvm.func @__catalyst__qis__Expval(i64) -> f64 - llvm.func @__catalyst__qis__NamedObs(i64, !llvm.ptr) -> i64 - llvm.func @__catalyst__qis__RX(f64, !llvm.ptr, !llvm.ptr) - llvm.func @__catalyst__rt__array_get_element_ptr_1d(!llvm.ptr, i64) -> !llvm.ptr - llvm.func @__catalyst__rt__qubit_allocate_array(i64) -> !llvm.ptr - llvm.mlir.global internal constant @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"("{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @LightningSimulator("LightningSimulator\00") {addr_space = 0 : i32} - llvm.mlir.global internal constant @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib"("/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00") {addr_space = 0 : i32} - llvm.func @__catalyst__rt__device_init(!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) - llvm.func @_mlir_memref_to_llvm_alloc(i64) -> !llvm.ptr - llvm.func @jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.zero : !llvm.ptr - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(3735928559 : index) : i64 - %4 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %5 = llvm.call @test_pipeline_lowering_workflow_0(%arg0, %arg1, %arg2) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - %6 = llvm.extractvalue %5[0] : !llvm.struct<(ptr, ptr, i64)> - %7 = llvm.ptrtoint %6 : !llvm.ptr to i64 - %8 = llvm.icmp "eq" %3, %7 : i64 - llvm.cond_br %8, ^bb1, ^bb2 - ^bb1: // pred: ^bb0 - %9 = llvm.getelementptr %1[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %10 = llvm.ptrtoint %9 : !llvm.ptr to i64 - %11 = llvm.call @_mlir_memref_to_llvm_alloc(%10) : (i64) -> !llvm.ptr - %12 = llvm.insertvalue %11, %4[0] : !llvm.struct<(ptr, ptr, i64)> - %13 = llvm.insertvalue %11, %12[1] : !llvm.struct<(ptr, ptr, i64)> - %14 = llvm.insertvalue %0, %13[2] : !llvm.struct<(ptr, ptr, i64)> - %15 = llvm.getelementptr %1[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %16 = llvm.ptrtoint %15 : !llvm.ptr to i64 - %17 = llvm.mul %16, %2 : i64 - %18 = llvm.extractvalue %5[1] : !llvm.struct<(ptr, ptr, i64)> - %19 = llvm.extractvalue %5[2] : !llvm.struct<(ptr, ptr, i64)> - %20 = llvm.getelementptr inbounds %18[%19] : (!llvm.ptr, i64) -> !llvm.ptr, f64 - "llvm.intr.memcpy"(%11, %20, %17) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> () - llvm.br ^bb3(%14 : !llvm.struct<(ptr, ptr, i64)>) - ^bb2: // pred: ^bb0 - llvm.br ^bb3(%5 : !llvm.struct<(ptr, ptr, i64)>) - ^bb3(%21: !llvm.struct<(ptr, ptr, i64)>): // 2 preds: ^bb1, ^bb2 - llvm.br ^bb4 - ^bb4: // pred: ^bb3 - llvm.return %21 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @_catalyst_pyface_jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) { - %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr)> - %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr)> - llvm.call @_catalyst_ciface_jit_test_pipeline_lowering_workflow(%arg0, %1) : (!llvm.ptr, !llvm.ptr) -> () - llvm.return - } - llvm.func @_catalyst_ciface_jit_test_pipeline_lowering_workflow(%arg0: !llvm.ptr, %arg1: !llvm.ptr) attributes {llvm.copy_memref, llvm.emit_c_interface} { - %0 = llvm.load %arg1 : !llvm.ptr -> !llvm.struct<(ptr, ptr, i64)> - %1 = llvm.extractvalue %0[0] : !llvm.struct<(ptr, ptr, i64)> - %2 = llvm.extractvalue %0[1] : !llvm.struct<(ptr, ptr, i64)> - %3 = llvm.extractvalue %0[2] : !llvm.struct<(ptr, ptr, i64)> - %4 = llvm.call @jit_test_pipeline_lowering_workflow(%1, %2, %3) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.struct<(ptr, ptr, i64)> - llvm.store %4, %arg0 : !llvm.struct<(ptr, ptr, i64)>, !llvm.ptr - llvm.return - } - llvm.func internal @test_pipeline_lowering_workflow_0(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64) -> !llvm.struct<(ptr, ptr, i64)> attributes {diff_method = "adjoint", qnode} { - %0 = llvm.mlir.constant(0 : index) : i64 - %1 = llvm.mlir.constant(64 : index) : i64 - %2 = llvm.mlir.constant(1 : index) : i64 - %3 = llvm.mlir.constant(1 : i64) : i64 - %4 = llvm.mlir.zero : !llvm.ptr - %5 = llvm.mlir.constant(2 : i64) : i64 - %6 = llvm.mlir.constant(false) : i1 - %7 = llvm.mlir.addressof @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" : !llvm.ptr - %8 = llvm.mlir.addressof @LightningSimulator : !llvm.ptr - %9 = llvm.mlir.addressof @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" : !llvm.ptr - %10 = llvm.mlir.constant(0 : i64) : i64 - %11 = llvm.mlir.poison : !llvm.struct<(ptr, ptr, i64)> - %12 = llvm.getelementptr inbounds %9[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<118 x i8> - %13 = llvm.getelementptr inbounds %8[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<19 x i8> - %14 = llvm.getelementptr inbounds %7[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<54 x i8> - llvm.call @__catalyst__rt__device_init(%12, %13, %14, %10, %6) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i1) -> () - %15 = llvm.call @__catalyst__rt__qubit_allocate_array(%5) : (i64) -> !llvm.ptr - %16 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %10) : (!llvm.ptr, i64) -> !llvm.ptr - %17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr - %18 = llvm.load %arg1 : !llvm.ptr -> f64 - llvm.call @__catalyst__qis__RX(%18, %17, %4) : (f64, !llvm.ptr, !llvm.ptr) -> () - %19 = llvm.call @__catalyst__rt__array_get_element_ptr_1d(%15, %3) : (!llvm.ptr, i64) -> !llvm.ptr - %20 = llvm.call @__catalyst__qis__NamedObs(%5, %17) : (i64, !llvm.ptr) -> i64 - %21 = llvm.call @__catalyst__qis__Expval(%20) : (i64) -> f64 - %22 = llvm.getelementptr %4[1] : (!llvm.ptr) -> !llvm.ptr, f64 - %23 = llvm.ptrtoint %22 : !llvm.ptr to i64 - %24 = llvm.add %23, %1 : i64 - %25 = llvm.call @_mlir_memref_to_llvm_alloc(%24) : (i64) -> !llvm.ptr - %26 = llvm.ptrtoint %25 : !llvm.ptr to i64 - %27 = llvm.sub %1, %2 : i64 - %28 = llvm.add %26, %27 : i64 - %29 = llvm.urem %28, %1 : i64 - %30 = llvm.sub %28, %29 : i64 - %31 = llvm.inttoptr %30 : i64 to !llvm.ptr - %32 = llvm.insertvalue %25, %11[0] : !llvm.struct<(ptr, ptr, i64)> - %33 = llvm.insertvalue %31, %32[1] : !llvm.struct<(ptr, ptr, i64)> - %34 = llvm.insertvalue %0, %33[2] : !llvm.struct<(ptr, ptr, i64)> - llvm.store %21, %31 : f64, !llvm.ptr - llvm.call @__catalyst__rt__qubit_release_array(%15) : (!llvm.ptr) -> () - llvm.call @__catalyst__rt__device_release() : () -> () - llvm.return %34 : !llvm.struct<(ptr, ptr, i64)> - } - llvm.func @setup() { - %0 = llvm.mlir.zero : !llvm.ptr - llvm.call @__catalyst__rt__initialize(%0) : (!llvm.ptr) -> () - llvm.return - } - llvm.func @teardown() { - llvm.call @__catalyst__rt__finalize() : () -> () - llvm.return - } -} \ No newline at end of file diff --git a/test_pipeline_lowering_workflow_6/6_llvm_ir.ll b/test_pipeline_lowering_workflow_6/6_llvm_ir.ll deleted file mode 100644 index c5b40ab21d..0000000000 --- a/test_pipeline_lowering_workflow_6/6_llvm_ir.ll +++ /dev/null @@ -1,118 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" - -@"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}" = internal constant [54 x i8] c"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}\00" -@LightningSimulator = internal constant [19 x i8] c"LightningSimulator\00" -@"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib" = internal constant [118 x i8] c"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib\00" - -declare void @__catalyst__rt__finalize() - -declare void @__catalyst__rt__initialize(ptr) - -declare void @__catalyst__rt__device_release() - -declare void @__catalyst__rt__qubit_release_array(ptr) - -declare double @__catalyst__qis__Expval(i64) - -declare i64 @__catalyst__qis__NamedObs(i64, ptr) - -declare void @__catalyst__qis__RX(double, ptr, ptr) - -declare ptr @__catalyst__rt__array_get_element_ptr_1d(ptr, i64) - -declare ptr @__catalyst__rt__qubit_allocate_array(i64) - -declare void @__catalyst__rt__device_init(ptr, ptr, ptr, i64, i1) - -declare ptr @_mlir_memref_to_llvm_alloc(i64) - -define { ptr, ptr, i64 } @jit_test_pipeline_lowering_workflow(ptr %0, ptr %1, i64 %2) { - %4 = call { ptr, ptr, i64 } @test_pipeline_lowering_workflow_0(ptr %0, ptr %1, i64 %2) - %5 = extractvalue { ptr, ptr, i64 } %4, 0 - %6 = ptrtoint ptr %5 to i64 - %7 = icmp eq i64 3735928559, %6 - br i1 %7, label %8, label %16 - -8: ; preds = %3 - %9 = call ptr @_mlir_memref_to_llvm_alloc(i64 8) - %10 = insertvalue { ptr, ptr, i64 } poison, ptr %9, 0 - %11 = insertvalue { ptr, ptr, i64 } %10, ptr %9, 1 - %12 = insertvalue { ptr, ptr, i64 } %11, i64 0, 2 - %13 = extractvalue { ptr, ptr, i64 } %4, 1 - %14 = extractvalue { ptr, ptr, i64 } %4, 2 - %15 = getelementptr inbounds double, ptr %13, i64 %14 - call void @llvm.memcpy.p0.p0.i64(ptr %9, ptr %15, i64 8, i1 false) - br label %17 - -16: ; preds = %3 - br label %17 - -17: ; preds = %8, %16 - %18 = phi { ptr, ptr, i64 } [ %4, %16 ], [ %12, %8 ] - br label %19 - -19: ; preds = %17 - ret { ptr, ptr, i64 } %18 -} - -define void @_catalyst_pyface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %1) { - %3 = load { ptr, ptr }, ptr %1, align 8 - %4 = extractvalue { ptr, ptr } %3, 0 - call void @_catalyst_ciface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %4) - ret void -} - -define void @_catalyst_ciface_jit_test_pipeline_lowering_workflow(ptr %0, ptr %1) { - %3 = load { ptr, ptr, i64 }, ptr %1, align 8 - %4 = extractvalue { ptr, ptr, i64 } %3, 0 - %5 = extractvalue { ptr, ptr, i64 } %3, 1 - %6 = extractvalue { ptr, ptr, i64 } %3, 2 - %7 = call { ptr, ptr, i64 } @jit_test_pipeline_lowering_workflow(ptr %4, ptr %5, i64 %6) - store { ptr, ptr, i64 } %7, ptr %0, align 8 - ret void -} - -define internal { ptr, ptr, i64 } @test_pipeline_lowering_workflow_0(ptr %0, ptr %1, i64 %2) { - call void @__catalyst__rt__device_init(ptr @"/Users/christina/Prog/catalyst_env/lib/python3.12/site-packages/pennylane_lightning/liblightning_qubit_catalyst.dylib", ptr @LightningSimulator, ptr @"{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}", i64 0, i1 false) - %4 = call ptr @__catalyst__rt__qubit_allocate_array(i64 2) - %5 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 0) - %6 = load ptr, ptr %5, align 8 - %7 = load double, ptr %1, align 8 - call void @__catalyst__qis__RX(double %7, ptr %6, ptr null) - %8 = call ptr @__catalyst__rt__array_get_element_ptr_1d(ptr %4, i64 1) - %9 = call i64 @__catalyst__qis__NamedObs(i64 2, ptr %6) - %10 = call double @__catalyst__qis__Expval(i64 %9) - %11 = call ptr @_mlir_memref_to_llvm_alloc(i64 72) - %12 = ptrtoint ptr %11 to i64 - %13 = add i64 %12, 63 - %14 = urem i64 %13, 64 - %15 = sub i64 %13, %14 - %16 = inttoptr i64 %15 to ptr - %17 = insertvalue { ptr, ptr, i64 } poison, ptr %11, 0 - %18 = insertvalue { ptr, ptr, i64 } %17, ptr %16, 1 - %19 = insertvalue { ptr, ptr, i64 } %18, i64 0, 2 - store double %10, ptr %16, align 8 - call void @__catalyst__rt__qubit_release_array(ptr %4) - call void @__catalyst__rt__device_release() - ret { ptr, ptr, i64 } %19 -} - -define void @setup() { - call void @__catalyst__rt__initialize(ptr null) - ret void -} - -define void @teardown() { - call void @__catalyst__rt__finalize() - ret void -} - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg) #0 - -attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/test_pipeline_lowering_workflow_6/test_pipeline_lowering_workflow.o b/test_pipeline_lowering_workflow_6/test_pipeline_lowering_workflow.o deleted file mode 100644 index caced91192178fff3af454d907c7de877128823c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3104 zcmc&$T}&KR6h6ZOT?7}jXsd0?)|x8smd&vf_7U?uBJ3CiTUWz4OgE z-#O==duHa|{raz8{%#>M2*Q_ojBp(;Q4GjK7;pNlukO2KH~`YcF%YdE!aWZ~lMtSq z^VlO0A%@S73~Q|lRUXdAx2ugr4>Da(iws(XNT!|aZo+-}RGu3upbLfQT6B(Tc`GMWRF&oYA#lt%kPs;X9#4(OE5pBSTcpAiD39ErA=w1xw?pC&!jBhFn z4SB@9Tj-#2@f4MBc2c?Y!+YOe{qEZD9R~eu)X{L*SR5*Z!jG}vPo0T!=~SZpV~ExY zp^mj;sA=scMmTrz&n^S;hmq$9l?%tHj2hbu@GrvuW(P(Uhc&ks4ud-a`!S3|h-*e% zE8!mY<^=8&<;ueOJnCFo4~ZLss%F#^95^3^pFYy=x2=d;L3e$MUZxCiz5Vh9}3GR6vOTRsUy%a_jqZ(*Ic(4VbP zhu?#K3i?q%yr(7%RS&kVWbkmdZr0JP7Fz3tmVlV zzSv9Vq|C-M(s6RO=}2MgnK)oa5tpaOEKlf!r^j<(t4jDRxL050E}`uHw*~7yenYuF zb3lB3@WJZud|&+cif=z4{x`+99l$F)8S_JA%$+dWS~@5SU)~G0wgb^?p#I3{$Hqr^ zRf&#caLwz=hy8u&i?p#1^DkpuQ9S$l(jSRx{#6(j6~C!y%rU6>4`CZsyjmYoRsQSX z6N=aC(EJ}*_hF*g77($qb>RKL>p+|bu~py^AfHXx(_(J`BfvQza>b^At-wL0_W>V( z{sizo;G;mC2LsUndyfP0a0ZSB*xL?7qXyan?A=1G_aKgI#$FZc2J-y8x56cMCBVi- zg`)}+3Zn`E?BBQ!#Fl-65&M1QiqaXeKSvgo&Itd=sL~lRXC$F?Mr`?!<4R{losmya zd<217K2>_XvSF{L2*xM|OD9i)`-IZjjdgAU%lp7;{TH7U2fR5jewAAQxn7^98R>S{_$ZGzB8eZ1uuh-~L z*2KS3qu;LaC-L8QOo2ZldealGC)B=W+IAXtDNNTjbNDxPM=w{}(#-BU?PSX2Cd{N1 z7qJ6+65DCU%1GPd%`!bJUF^zYHtk-TfQHmNQAz7AqISdlvd86&g&8f!^7dAH*~$uW z0f)r+3u9RlcQ_YBR(jJJLZzlVo}P8?5PyCyGh^C&32xQ|P7d3em-`tm#5#aewW{vz zkM(;lCMAv`Tc)Ig{&}wG8HZ=ewp@{tDOXMiFD-0)CMEo5MdJTC(e}I(F-Q41TeHlbI{R8t>zFz Date: Wed, 3 Dec 2025 17:03:23 -0500 Subject: [PATCH 24/24] unpin pl branch --- .github/workflows/check-catalyst.yaml | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/.github/workflows/check-catalyst.yaml b/.github/workflows/check-catalyst.yaml index 2f97fec69d..999e5ad137 100644 --- a/.github/workflows/check-catalyst.yaml +++ b/.github/workflows/check-catalyst.yaml @@ -475,10 +475,6 @@ jobs: python3 -m pip install oqc-qcaas-client make frontend - - name: Install PennyLane branch - run: | - pip install --no-deps --force git+https://github.com/PennyLaneAI/pennylane@add-pass-name - - name: Get Cached LLVM Build id: cache-llvm-build uses: actions/cache@v4 @@ -562,10 +558,6 @@ jobs: python3 -m pip install -r requirements.txt make frontend - - name: Install PennyLane branch - run: | - pip install --no-deps --force git+https://github.com/PennyLaneAI/pennylane@add-pass-name - - name: Get Cached LLVM Build id: cache-llvm-build uses: actions/cache@v4 @@ -628,10 +620,6 @@ jobs: python3 -m pip install -r requirements.txt make frontend - - name: Install PennyLane branch - run: | - pip install --no-deps --force git+https://github.com/PennyLaneAI/pennylane@add-pass-name - - name: Get Cached LLVM Build id: cache-llvm-build uses: actions/cache@v4