5631006520

pending completion

Build # 5631006520

Build Type

push

github

Committed by

web-flow

Commit Message

Revert "Revert "Pass manager refactoring: add passmanager module (#10124)" (#10454)" (#10474)

This reverts commit c03e4c78b.

Run Details

413 of 413 new or added lines in 13 files covered. (100.0%)

73017 of 84977 relevant lines covered (85.93%)

60136.54 hits per line

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

95.88

/qiskit/transpiler/runningpassmanager.py

# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.

"""RunningPassManager class for the transpiler.
This object holds the state of a pass manager during running-time."""
from __future__ import annotations
import logging
import inspect
from functools import partial, wraps
from typing import Callable

from qiskit.circuit import QuantumCircuit
from qiskit.converters import circuit_to_dag, dag_to_circuit
from qiskit.dagcircuit import DAGCircuit
from qiskit.passmanager import BasePassRunner
from qiskit.passmanager.flow_controllers import (
    PassSequence,
    FlowController,
    DoWhileController,
    ConditionalController,
)
from qiskit.passmanager.exceptions import PassManagerError
from qiskit.transpiler.basepasses import BasePass
from .exceptions import TranspilerError
from .fencedobjs import FencedPropertySet, FencedDAGCircuit
from .layout import TranspileLayout

logger = logging.getLogger(__name__)


class RunningPassManager(BasePassRunner):
    """A RunningPassManager is a running pass manager."""

    IN_PROGRAM_TYPE = QuantumCircuit
    OUT_PROGRAM_TYPE = QuantumCircuit
    IR_TYPE = DAGCircuit

    def __init__(self, max_iteration: int):
        """Initialize an empty PassManager object (with no passes scheduled).

        Args:
            max_iteration: The schedule looping iterates until the condition is met or until
                max_iteration is reached.
        """
        super().__init__(max_iteration)
        self.fenced_property_set = FencedPropertySet(self.property_set)

    def append(
        self,
        passes: PassSequence,
        **flow_controller_conditions,
    ):
        """Append a passes to the schedule of passes.

        Args:
            passes: passes to be added to schedule
            flow_controller_conditions: See add_flow_controller(): Dictionary of
            control flow plugins. Default:

                * do_while (callable property_set -> boolean): The passes repeat until the
                  callable returns False.
                  Default: `lambda x: False # i.e. passes run once`

                * condition (callable property_set -> boolean): The passes run only if the
                  callable returns True.
                  Default: `lambda x: True # i.e. passes run`
        """
        # attaches the property set to the controller so it has access to it.
        if isinstance(passes, ConditionalController):
            passes.condition = partial(passes.condition, self.fenced_property_set)
        elif isinstance(passes, DoWhileController):
            if not isinstance(passes.do_while, partial):
                passes.do_while = partial(passes.do_while, self.fenced_property_set)
        else:
            flow_controller_conditions = self._normalize_flow_controller(flow_controller_conditions)
            passes = FlowController.controller_factory(
                passes, self.passmanager_options, **flow_controller_conditions
            )
        super().append(passes)

    def _normalize_flow_controller(self, flow_controller):
        for name, param in flow_controller.items():
            if callable(param):
                flow_controller[name] = partial(param, self.fenced_property_set)
            else:
                raise TranspilerError("The flow controller parameter %s is not callable" % name)
        return flow_controller

    def _to_passmanager_ir(self, in_program: QuantumCircuit) -> DAGCircuit:
        if not isinstance(in_program, QuantumCircuit):
            raise TranspilerError(f"Input {in_program.__class__} is not QuantumCircuit.")
        return circuit_to_dag(in_program)

    def _to_target(self, passmanager_ir: DAGCircuit) -> QuantumCircuit:
        if not isinstance(passmanager_ir, DAGCircuit):
            raise TranspilerError(f"Input {passmanager_ir.__class__} is not DAGCircuit.")

        circuit = dag_to_circuit(passmanager_ir, copy_operations=False)
        circuit.name = self.metadata["output_name"]

        if self.property_set["layout"] is not None:
            circuit._layout = TranspileLayout(
                initial_layout=self.property_set["layout"],
                input_qubit_mapping=self.property_set["original_qubit_indices"],
                final_layout=self.property_set["final_layout"],
            )
        circuit._clbit_write_latency = self.property_set["clbit_write_latency"]
        circuit._conditional_latency = self.property_set["conditional_latency"]

        if self.property_set["node_start_time"]:
            # This is dictionary keyed on the DAGOpNode, which is invalidated once
            # dag is converted into circuit. So this schedule information is
            # also converted into list with the same ordering with circuit.data.
            topological_start_times = []
            start_times = self.property_set["node_start_time"]
            for dag_node in passmanager_ir.topological_op_nodes():
                topological_start_times.append(start_times[dag_node])
            circuit._op_start_times = topological_start_times

        return circuit

    # pylint: disable=arguments-differ
    def run(
        self,
        circuit: QuantumCircuit,
        output_name: str = None,
        callback: Callable = None,
    ) -> QuantumCircuit:
        """Run all the passes on a QuantumCircuit

        Args:
            circuit: Circuit to transform via all the registered passes.
            output_name: The output circuit name. If not given, the same as the input circuit.
            callback: A callback function that will be called after each pass execution.

        Returns:
            QuantumCircuit: Transformed circuit.
        """
        return super().run(
            in_program=circuit,
            callback=_rename_callback_args(callback),
            output_name=output_name or circuit.name,
        )

    def _run_base_pass(
        self,
        pass_: BasePass,
        passmanager_ir: DAGCircuit,
    ) -> DAGCircuit:
        """Do either a pass and its "requires" or FlowController.

        Args:
            pass_: A base pass to run.
            passmanager_ir: Pass manager IR, i.e. DAGCircuit for this class.

        Returns:
            The transformed dag in case of a transformation pass.
            The same input dag in case of an analysis pass.

        Raises:
            TranspilerError: When transform pass returns non DAGCircuit.
            TranspilerError: When pass is neither transform pass nor analysis pass.
        """
        pass_.property_set = self.property_set

        if pass_.is_transformation_pass:
            # Measure time if we have a callback or logging set
            new_dag = pass_.run(passmanager_ir)
            if isinstance(new_dag, DAGCircuit):
                new_dag.calibrations = passmanager_ir.calibrations
            else:
                raise TranspilerError(
                    "Transformation passes should return a transformed dag."
                    "The pass %s is returning a %s" % (type(pass_).__name__, type(new_dag))
                )
            passmanager_ir = new_dag
        elif pass_.is_analysis_pass:
            # Measure time if we have a callback or logging set
            pass_.run(FencedDAGCircuit(passmanager_ir))
        else:
            raise TranspilerError("I dont know how to handle this type of pass")
        return passmanager_ir

    def _update_valid_passes(self, pass_):
        super()._update_valid_passes(pass_)
        if not pass_.is_analysis_pass:  # Analysis passes preserve all
            self.valid_passes.intersection_update(set(pass_.preserves))


def _rename_callback_args(callback):
    """A helper function to run callback with conventional argument names."""
    if callback is None:
        return callback

    def _call_with_dag(pass_, passmanager_ir, time, property_set, count):
        callback(
            pass_=pass_,
            dag=passmanager_ir,
            time=time,
            property_set=property_set,
            count=count,
        )

    return _call_with_dag


# A temporary error handling with slight overhead at class loading.
# This method wraps all class methods to replace PassManagerError with TranspilerError.
# The pass flow controller mechanics raises PassManagerError, as it has been moved to base class.
# PassManagerError is not caught by TranspilerError due to the hierarchy.


def _replace_error(meth):
    @wraps(meth)
    def wrapper(*meth_args, **meth_kwargs):
        try:
            return meth(*meth_args, **meth_kwargs)
        except PassManagerError as ex:
            raise TranspilerError(ex.message) from ex

    return wrapper


for _name, _method in inspect.getmembers(RunningPassManager, predicate=inspect.isfunction):
    if _name.startswith("_"):
        # Ignore protected and private.
        # User usually doesn't directly execute and catch error from these methods.
        continue
    _wrapped = _replace_error(_method)
    setattr(RunningPassManager, _name, _wrapped)

1	# This code is part of Qiskit.
2	#
3	# (C) Copyright IBM 2017, 2019.
4	#
5	# This code is licensed under the Apache License, Version 2.0. You may
6	# obtain a copy of this license in the LICENSE.txt file in the root directory
7	# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
8	#
9	# Any modifications or derivative works of this code must retain this
10	# copyright notice, and modified files need to carry a notice indicating
11	# that they have been altered from the originals.
12
13	"""RunningPassManager class for the transpiler.	1✔
14	This object holds the state of a pass manager during running-time."""
15	from __future__ import annotations	1✔
16	import logging	1✔
17	import inspect	1✔
18	from functools import partial, wraps	1✔
19	from typing import Callable	1✔
20
21	from qiskit.circuit import QuantumCircuit	1✔
22	from qiskit.converters import circuit_to_dag, dag_to_circuit	1✔
23	from qiskit.dagcircuit import DAGCircuit	1✔
24	from qiskit.passmanager import BasePassRunner	1✔
25	from qiskit.passmanager.flow_controllers import (	1✔
26	PassSequence,
27	FlowController,
28	DoWhileController,
29	ConditionalController,
30	)
31	from qiskit.passmanager.exceptions import PassManagerError	1✔
32	from qiskit.transpiler.basepasses import BasePass	1✔
33	from .exceptions import TranspilerError	1✔
34	from .fencedobjs import FencedPropertySet, FencedDAGCircuit	1✔
35	from .layout import TranspileLayout	1✔
36
37	logger = logging.getLogger(__name__)	1✔
38
39
40	class RunningPassManager(BasePassRunner):	1✔
41	"""A RunningPassManager is a running pass manager."""	1✔
42
43	IN_PROGRAM_TYPE = QuantumCircuit	1✔
44	OUT_PROGRAM_TYPE = QuantumCircuit	1✔
45	IR_TYPE = DAGCircuit	1✔
46
47	def __init__(self, max_iteration: int):	1✔
48	"""Initialize an empty PassManager object (with no passes scheduled).
49
50	Args:
51	max_iteration: The schedule looping iterates until the condition is met or until
52	max_iteration is reached.
53	"""
54	super().__init__(max_iteration)	1✔
55	self.fenced_property_set = FencedPropertySet(self.property_set)	1✔
56
57	def append(	1✔
58	self,
59	passes: PassSequence,
60	**flow_controller_conditions,
61	):
62	"""Append a passes to the schedule of passes.
63
64	Args:
65	passes: passes to be added to schedule
66	flow_controller_conditions: See add_flow_controller(): Dictionary of
67	control flow plugins. Default:
68
69	* do_while (callable property_set -> boolean): The passes repeat until the
70	callable returns False.
71	Default: `lambda x: False # i.e. passes run once`
72
73	* condition (callable property_set -> boolean): The passes run only if the
74	callable returns True.
75	Default: `lambda x: True # i.e. passes run`
76	"""
77	# attaches the property set to the controller so it has access to it.
78	if isinstance(passes, ConditionalController):	1✔
79	passes.condition = partial(passes.condition, self.fenced_property_set)	1✔
80	elif isinstance(passes, DoWhileController):	1✔
81	if not isinstance(passes.do_while, partial):	1✔
82	passes.do_while = partial(passes.do_while, self.fenced_property_set)	1✔
83	else:
84	flow_controller_conditions = self._normalize_flow_controller(flow_controller_conditions)	1✔
85	passes = FlowController.controller_factory(	1✔
86	passes, self.passmanager_options, **flow_controller_conditions
87	)
88	super().append(passes)	1✔
89
90	def _normalize_flow_controller(self, flow_controller):	1✔
91	for name, param in flow_controller.items():	1✔
92	if callable(param):	1✔
93	flow_controller[name] = partial(param, self.fenced_property_set)	1✔
94	else:
95	raise TranspilerError("The flow controller parameter %s is not callable" % name)	×
96	return flow_controller	1✔
97
98	def _to_passmanager_ir(self, in_program: QuantumCircuit) -> DAGCircuit:	1✔
99	if not isinstance(in_program, QuantumCircuit):	1✔
100	raise TranspilerError(f"Input {in_program.__class__} is not QuantumCircuit.")	×
101	return circuit_to_dag(in_program)	1✔
102
103	def _to_target(self, passmanager_ir: DAGCircuit) -> QuantumCircuit:	1✔
104	if not isinstance(passmanager_ir, DAGCircuit):	1✔
105	raise TranspilerError(f"Input {passmanager_ir.__class__} is not DAGCircuit.")	×
106
107	circuit = dag_to_circuit(passmanager_ir, copy_operations=False)	1✔
108	circuit.name = self.metadata["output_name"]	1✔
109
110	if self.property_set["layout"] is not None:	1✔
111	circuit._layout = TranspileLayout(	1✔
112	initial_layout=self.property_set["layout"],
113	input_qubit_mapping=self.property_set["original_qubit_indices"],
114	final_layout=self.property_set["final_layout"],
115	)
116	circuit._clbit_write_latency = self.property_set["clbit_write_latency"]	1✔
117	circuit._conditional_latency = self.property_set["conditional_latency"]	1✔
118
119	if self.property_set["node_start_time"]:	1✔
120	# This is dictionary keyed on the DAGOpNode, which is invalidated once
121	# dag is converted into circuit. So this schedule information is
122	# also converted into list with the same ordering with circuit.data.
123	topological_start_times = []	1✔
124	start_times = self.property_set["node_start_time"]	1✔
125	for dag_node in passmanager_ir.topological_op_nodes():	1✔
126	topological_start_times.append(start_times[dag_node])	1✔
127	circuit._op_start_times = topological_start_times	1✔
128
129	return circuit	1✔
130
131	# pylint: disable=arguments-differ
132	def run(	1✔
133	self,
134	circuit: QuantumCircuit,
135	output_name: str = None,
136	callback: Callable = None,
137	) -> QuantumCircuit:
138	"""Run all the passes on a QuantumCircuit
139
140	Args:
141	circuit: Circuit to transform via all the registered passes.
142	output_name: The output circuit name. If not given, the same as the input circuit.
143	callback: A callback function that will be called after each pass execution.
144
145	Returns:
146	QuantumCircuit: Transformed circuit.
147	"""
148	return super().run(	1✔
149	in_program=circuit,
150	callback=_rename_callback_args(callback),
151	output_name=output_name or circuit.name,
152	)
153
154	def _run_base_pass(	1✔
155	self,
156	pass_: BasePass,
157	passmanager_ir: DAGCircuit,
158	) -> DAGCircuit:
159	"""Do either a pass and its "requires" or FlowController.
160
161	Args:
162	pass_: A base pass to run.
163	passmanager_ir: Pass manager IR, i.e. DAGCircuit for this class.
164
165	Returns:
166	The transformed dag in case of a transformation pass.
167	The same input dag in case of an analysis pass.
168
169	Raises:
170	TranspilerError: When transform pass returns non DAGCircuit.
171	TranspilerError: When pass is neither transform pass nor analysis pass.
172	"""
173	pass_.property_set = self.property_set	1✔
174
175	if pass_.is_transformation_pass:	1✔
176	# Measure time if we have a callback or logging set
177	new_dag = pass_.run(passmanager_ir)	1✔
178	if isinstance(new_dag, DAGCircuit):	1✔
179	new_dag.calibrations = passmanager_ir.calibrations	1✔
180	else:
181	raise TranspilerError(	1✔
182	"Transformation passes should return a transformed dag."
183	"The pass %s is returning a %s" % (type(pass_).__name__, type(new_dag))
184	)
185	passmanager_ir = new_dag	1✔
186	elif pass_.is_analysis_pass:	1✔
187	# Measure time if we have a callback or logging set
188	pass_.run(FencedDAGCircuit(passmanager_ir))	1✔
189	else:
190	raise TranspilerError("I dont know how to handle this type of pass")	×
191	return passmanager_ir	1✔
192
193	def _update_valid_passes(self, pass_):	1✔
194	super()._update_valid_passes(pass_)	1✔
195	if not pass_.is_analysis_pass: # Analysis passes preserve all	1✔
196	self.valid_passes.intersection_update(set(pass_.preserves))	1✔
197
198
199	def _rename_callback_args(callback):	1✔
200	"""A helper function to run callback with conventional argument names."""
201	if callback is None:	1✔
202	return callback	1✔
203
204	def _call_with_dag(pass_, passmanager_ir, time, property_set, count):	1✔
205	callback(	1✔
206	pass_=pass_,
207	dag=passmanager_ir,
208	time=time,
209	property_set=property_set,
210	count=count,
211	)
212
213	return _call_with_dag	1✔
214
215
216	# A temporary error handling with slight overhead at class loading.
217	# This method wraps all class methods to replace PassManagerError with TranspilerError.
218	# The pass flow controller mechanics raises PassManagerError, as it has been moved to base class.
219	# PassManagerError is not caught by TranspilerError due to the hierarchy.
220
221
222	def _replace_error(meth):	1✔
223	@wraps(meth)	1✔
224	def wrapper(meth_args, *meth_kwargs):	1✔
225	try:	1✔
226	return meth(meth_args, *meth_kwargs)	1✔
227	except PassManagerError as ex:	1✔
228	raise TranspilerError(ex.message) from ex	1✔
229
230	return wrapper	1✔
231
232
233	for _name, _method in inspect.getmembers(RunningPassManager, predicate=inspect.isfunction):	1✔
234	if _name.startswith("_"):	1✔
235	# Ignore protected and private.
236	# User usually doesn't directly execute and catch error from these methods.
237	continue	1✔
238	_wrapped = _replace_error(_method)	1✔
239	setattr(RunningPassManager, _name, _wrapped)	1✔

Qiskit / qiskit-terra / 5631006520

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

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