qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0__cp38-abi3-win32.whl

qiskit/transpiler/passes/utils/convert_conditions_to_if_ops.py

@@ -17,12 +17,11 @@ from qiskit.circuit import (
     CircuitInstruction,
     ClassicalRegister,
     Clbit,
-    ControlFlowOp,
     IfElseOp,
     QuantumCircuit,
 )
 from qiskit.dagcircuit import DAGCircuit
-from qiskit.transpiler import TransformationPass
+from qiskit.transpiler.basepasses import TransformationPass
 
 
 class ConvertConditionsToIfOps(TransformationPass):
@@ -37,7 +36,7 @@ class ConvertConditionsToIfOps(TransformationPass):
         was modified and ``False`` if not."""
         modified = False
         for node in dag.op_nodes():
-            if isinstance(node.op, ControlFlowOp):
+            if node.is_control_flow():
                 modified_blocks = False
                 new_dags = []
                 for block in node.op.blocks:
@@ -51,7 +50,7 @@ class ConvertConditionsToIfOps(TransformationPass):
                     node.op.replace_blocks(dag_to_circuit(block) for block in new_dags),
                     inplace=True,
                 )
-            elif getattr(node.op, "condition", None) is None:
+            elif node.condition is None:
                 continue
             else:
                 target, value = node.op.condition

qiskit/transpiler/passes/utils/error.py

@@ -43,7 +43,7 @@ class Error(AnalysisPass):
         if action in ["raise", "warn", "log"]:
             self.action = action
         else:
-            raise TranspilerError("Unknown action: %s" % action)
+            raise TranspilerError(f"Unknown action: {action}")
 
     def run(self, _):
         """Run the Error pass on `dag`."""
@@ -66,4 +66,4 @@ class Error(AnalysisPass):
             logger = logging.getLogger(__name__)
             logger.info(msg)
         else:
-            raise TranspilerError("Unknown action: %s" % self.action)
+            raise TranspilerError(f"Unknown action: {self.action}")

qiskit/transpiler/passes/utils/fixed_point.py

@@ -37,12 +37,12 @@ class FixedPoint(AnalysisPass):
     def run(self, dag):
         """Run the FixedPoint pass on `dag`."""
         current_value = self.property_set[self._property]
-        fixed_point_previous_property = "_fixed_point_previous_%s" % self._property
+        fixed_point_previous_property = f"_fixed_point_previous_{self._property}"
 
         if self.property_set[fixed_point_previous_property] is None:
-            self.property_set["%s_fixed_point" % self._property] = False
+            self.property_set[f"{self._property}_fixed_point"] = False
         else:
             fixed_point_reached = self.property_set[fixed_point_previous_property] == current_value
-            self.property_set["%s_fixed_point" % self._property] = fixed_point_reached
+            self.property_set[f"{self._property}_fixed_point"] = fixed_point_reached
 
         self.property_set[fixed_point_previous_property] = deepcopy(current_value)

qiskit/transpiler/passes/utils/gate_direction.py

@@ -67,7 +67,7 @@ class GateDirection(TransformationPass):
              └──────┘          └───┘└──────┘└───┘
 
     This pass assumes that the positions of the qubits in the :attr:`.DAGCircuit.qubits` attribute
-    are the physical qubit indicies. For example if ``dag.qubits[0]`` is qubit 0 in the
+    are the physical qubit indices. For example if ``dag.qubits[0]`` is qubit 0 in the
     :class:`.CouplingMap` or :class:`.Target`.
     """
 

qiskit/transpiler/passes/utils/gates_basis.py

@@ -12,7 +12,6 @@
 
 """Check if all gates in the DAGCircuit are in the specified basis gates."""
 
-from qiskit.circuit import ControlFlowOp
 from qiskit.converters import circuit_to_dag
 from qiskit.transpiler.basepasses import AnalysisPass
 
@@ -55,7 +54,7 @@ class GatesInBasis(AnalysisPass):
                         return True
                     # Control-flow ops still need to be supported, so don't skip them in the
                     # previous checks.
-                    if isinstance(gate.op, ControlFlowOp):
+                    if gate.is_control_flow():
                         for block in gate.op.blocks:
                             inner_wire_map = {
                                 inner: wire_map[outer]

qiskit/transpiler/passmanager.py

@@ -18,7 +18,7 @@ import io
 import re
 from collections.abc import Iterator, Iterable, Callable
 from functools import wraps
-from typing import Union, List, Any
+from typing import Union, List, Any, TypeVar
 
 from qiskit.circuit import QuantumCircuit
 from qiskit.converters import circuit_to_dag, dag_to_circuit
@@ -31,7 +31,7 @@ from .basepasses import BasePass
 from .exceptions import TranspilerError
 from .layout import TranspileLayout, Layout
 
-_CircuitsT = Union[List[QuantumCircuit], QuantumCircuit]
+_CircuitsT = TypeVar("_CircuitsT", bound=Union[List[QuantumCircuit], QuantumCircuit])
 
 
 class PassManager(BasePassManager):
@@ -121,6 +121,7 @@ class PassManager(BasePassManager):
         # Ordered list of original qubits
         original_qubits_reverse = {v: k for k, v in original_qubit_indices.items()}
         original_qubits = []
+        # pylint: disable-next=consider-using-enumerate
         for i in range(len(original_qubits_reverse)):
             original_qubits.append(original_qubits_reverse[i])
 
@@ -139,7 +140,7 @@ class PassManager(BasePassManager):
         self.property_set["layout"] = t_initial_layout
         self.property_set["final_layout"] = new_final_layout
 
-    def append(
+    def append(  # pylint:disable=arguments-renamed
         self,
         passes: Task | list[Task],
     ) -> None:
@@ -153,7 +154,7 @@ class PassManager(BasePassManager):
         """
         super().append(tasks=passes)
 
-    def replace(
+    def replace(  # pylint:disable=arguments-renamed
         self,
         index: int,
         passes: Task | list[Task],
@@ -167,7 +168,7 @@ class PassManager(BasePassManager):
         super().replace(index, tasks=passes)
 
     # pylint: disable=arguments-differ
-    def run(
+    def run(  # pylint:disable=arguments-renamed
         self,
         circuits: _CircuitsT,
         output_name: str | None = None,
@@ -337,7 +338,7 @@ class StagedPassManager(PassManager):
             "scheduling",
         ]
         self._validate_stages(stages)
-        # Set through parent class since `__setattr__` requieres `expanded_stages` to be defined
+        # Set through parent class since `__setattr__` requires `expanded_stages` to be defined
         super().__setattr__("_stages", tuple(stages))
         super().__setattr__("_expanded_stages", tuple(self._generate_expanded_stages()))
         super().__init__()

qiskit/transpiler/preset_passmanagers/__init__.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2017, 2019.
+# (C) Copyright IBM 2017, 2024.
 #
 # 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
@@ -21,7 +21,8 @@ This module contains functions for generating the preset pass managers
 for the transpiler. The preset pass managers are instances of
 :class:`~.StagedPassManager` which are used to execute the circuit
 transformations as part of Qiskit's compiler inside the
-:func:`~.transpile` function at the different optimization levels.
+:func:`~.transpile` function at the different optimization levels, but
+can also be used in a standalone manner.
 The functionality here is divided into two parts, the first includes the
 functions used generate the entire pass manager which is used by
 :func:`~.transpile` (:ref:`preset_pass_manager_generators`) and the
@@ -56,238 +57,13 @@ Stage Generator Functions
 .. autofunction:: generate_scheduling
 .. currentmodule:: qiskit.transpiler.preset_passmanagers
 """
-
-import warnings
-
-from qiskit.transpiler.passmanager_config import PassManagerConfig
-from qiskit.transpiler.target import target_to_backend_properties
-from qiskit.transpiler import CouplingMap
-
+from .generate_preset_pass_manager import generate_preset_pass_manager
 from .level0 import level_0_pass_manager
 from .level1 import level_1_pass_manager
 from .level2 import level_2_pass_manager
 from .level3 import level_3_pass_manager
 
 
-def generate_preset_pass_manager(
-    optimization_level,
-    backend=None,
-    target=None,
-    basis_gates=None,
-    inst_map=None,
-    coupling_map=None,
-    instruction_durations=None,
-    backend_properties=None,
-    timing_constraints=None,
-    initial_layout=None,
-    layout_method=None,
-    routing_method=None,
-    translation_method=None,
-    scheduling_method=None,
-    approximation_degree=1.0,
-    seed_transpiler=None,
-    unitary_synthesis_method="default",
-    unitary_synthesis_plugin_config=None,
-    hls_config=None,
-    init_method=None,
-    optimization_method=None,
-    *,
-    _skip_target=False,
-):
-    """Generate a preset :class:`~.PassManager`
-
-    This function is used to quickly generate a preset pass manager. Preset pass
-    managers are the default pass managers used by the :func:`~.transpile`
-    function. This function provides a convenient and simple method to construct
-    a standalone :class:`~.PassManager` object that mirrors what the :func:`~.transpile`
-    function internally builds and uses.
-
-    The target constraints for the pass manager construction can be specified through a :class:`.Target`
-    instance, a :class:`.BackendV1` or :class:`.BackendV2` instance, or via loose constraints
-    (``basis_gates``, ``inst_map``, ``coupling_map``, ``backend_properties``, ``instruction_durations``,
-    ``dt`` or ``timing_constraints``).
-    The order of priorities for target constraints works as follows: if a ``target``
-    input is provided, it will take priority over any ``backend`` input or loose constraints.
-    If a ``backend`` is provided together with any loose constraint
-    from the list above, the loose constraint will take priority over the corresponding backend
-    constraint. This behavior is independent of whether the ``backend`` instance is of type
-    :class:`.BackendV1` or :class:`.BackendV2`, as summarized in the table below. The first column
-    in the table summarizes the potential user-provided constraints, and each cell shows whether
-    the priority is assigned to that specific constraint input or another input
-    (`target`/`backend(V1)`/`backend(V2)`).
-
-    ============================ ========= ======================== =======================
-    User Provided                target    backend(V1)              backend(V2)
-    ============================ ========= ======================== =======================
-    **basis_gates**              target    basis_gates              basis_gates
-    **coupling_map**             target    coupling_map             coupling_map
-    **instruction_durations**    target    instruction_durations    instruction_durations
-    **inst_map**                 target    inst_map                 inst_map
-    **dt**                       target    dt                       dt
-    **timing_constraints**       target    timing_constraints       timing_constraints
-    **backend_properties**       target    backend_properties       backend_properties
-    ============================ ========= ======================== =======================
-
-    Args:
-        optimization_level (int): The optimization level to generate a
-            :class:`~.PassManager` for. This can be 0, 1, 2, or 3. Higher
-            levels generate more optimized circuits, at the expense of
-            longer transpilation time:
-
-                * 0: no optimization
-                * 1: light optimization
-                * 2: heavy optimization
-                * 3: even heavier optimization
-
-        backend (Backend): An optional backend object which can be used as the
-            source of the default values for the ``basis_gates``, ``inst_map``,
-            ``coupling_map``, ``backend_properties``, ``instruction_durations``,
-            ``timing_constraints``, and ``target``. If any of those other arguments
-            are specified in addition to ``backend`` they will take precedence
-            over the value contained in the backend.
-        target (Target): The :class:`~.Target` representing a backend compilation
-            target. The following attributes will be inferred from this
-            argument if they are not set: ``coupling_map``, ``basis_gates``,
-            ``instruction_durations``, ``inst_map``, ``timing_constraints``
-            and ``backend_properties``.
-        basis_gates (list): List of basis gate names to unroll to
-            (e.g: ``['u1', 'u2', 'u3', 'cx']``).
-        inst_map (InstructionScheduleMap): Mapping object that maps gate to schedules.
-            If any user defined calibration is found in the map and this is used in a
-            circuit, transpiler attaches the custom gate definition to the circuit.
-            This enables one to flexibly override the low-level instruction
-            implementation.
-        coupling_map (CouplingMap or list): Directed graph represented a coupling
-            map.
-        instruction_durations (InstructionDurations): Dictionary of duration
-            (in dt) for each instruction.
-        timing_constraints (TimingConstraints): Hardware time alignment restrictions.
-        initial_layout (Layout | List[int]): Initial position of virtual qubits on
-            physical qubits.
-        layout_method (str): The :class:`~.Pass` to use for choosing initial qubit
-            placement. Valid choices are ``'trivial'``, ``'dense'``,
-            and ``'sabre'``, representing :class:`~.TrivialLayout`, :class:`~.DenseLayout` and
-            :class:`~.SabreLayout` respectively. This can also
-            be the external plugin name to use for the ``layout`` stage of the output
-            :class:`~.StagedPassManager`. You can see a list of installed plugins by using
-            :func:`~.list_stage_plugins` with ``"layout"`` for the ``stage_name`` argument.
-        routing_method (str): The pass to use for routing qubits on the
-            architecture. Valid choices are ``'basic'``, ``'lookahead'``, ``'stochastic'``,
-            ``'sabre'``, and ``'none'`` representing :class:`~.BasicSwap`,
-            :class:`~.LookaheadSwap`, :class:`~.StochasticSwap`, :class:`~.SabreSwap`, and
-            erroring if routing is required respectively. This can also be the external plugin
-            name to use for the ``routing`` stage of the output :class:`~.StagedPassManager`.
-            You can see a list of installed plugins by using :func:`~.list_stage_plugins` with
-            ``"routing"`` for the ``stage_name`` argument.
-        translation_method (str): The method to use for translating gates to
-            basis gates. Valid choices ``'translator'``, ``'synthesis'`` representing
-            :class:`~.BasisTranslator`, and :class:`~.UnitarySynthesis` respectively. This can
-            also be the external plugin name to use for the ``translation`` stage of the output
-            :class:`~.StagedPassManager`. You can see a list of installed plugins by using
-            :func:`~.list_stage_plugins` with ``"translation"`` for the ``stage_name`` argument.
-        scheduling_method (str): The pass to use for scheduling instructions. Valid choices
-            are ``'alap'`` and ``'asap'``. This can also be the external plugin name to use
-            for the ``scheduling`` stage of the output :class:`~.StagedPassManager`. You can
-            see a list of installed plugins by using :func:`~.list_stage_plugins` with
-            ``"scheduling"`` for the ``stage_name`` argument.
-        backend_properties (BackendProperties): Properties returned by a
-            backend, including information on gate errors, readout errors,
-            qubit coherence times, etc.
-        approximation_degree (float): Heuristic dial used for circuit approximation
-            (1.0=no approximation, 0.0=maximal approximation).
-        seed_transpiler (int): Sets random seed for the stochastic parts of
-            the transpiler.
-        unitary_synthesis_method (str): The name of the unitary synthesis
-            method to use. By default ``'default'`` is used. You can see a list of
-            installed plugins with :func:`.unitary_synthesis_plugin_names`.
-        unitary_synthesis_plugin_config (dict): An optional configuration dictionary
-            that will be passed directly to the unitary synthesis plugin. By
-            default this setting will have no effect as the default unitary
-            synthesis method does not take custom configuration. This should
-            only be necessary when a unitary synthesis plugin is specified with
-            the ``unitary_synthesis_method`` argument. As this is custom for each
-            unitary synthesis plugin refer to the plugin documentation for how
-            to use this option.
-        hls_config (HLSConfig): An optional configuration class :class:`~.HLSConfig`
-            that will be passed directly to :class:`~.HighLevelSynthesis` transformation pass.
-            This configuration class allows to specify for various high-level objects
-            the lists of synthesis algorithms and their parameters.
-        init_method (str): The plugin name to use for the ``init`` stage of
-            the output :class:`~.StagedPassManager`. By default an external
-            plugin is not used. You can see a list of installed plugins by
-            using :func:`~.list_stage_plugins` with ``"init"`` for the stage
-            name argument.
-        optimization_method (str): The plugin name to use for the
-            ``optimization`` stage of the output
-            :class:`~.StagedPassManager`. By default an external
-            plugin is not used. You can see a list of installed plugins by
-            using :func:`~.list_stage_plugins` with ``"optimization"`` for the
-            ``stage_name`` argument.
-
-    Returns:
-        StagedPassManager: The preset pass manager for the given options
-
-    Raises:
-        ValueError: if an invalid value for ``optimization_level`` is passed in.
-    """
-
-    if coupling_map is not None and not isinstance(coupling_map, CouplingMap):
-        coupling_map = CouplingMap(coupling_map)
-
-    if target is not None:
-        if coupling_map is None:
-            coupling_map = target.build_coupling_map()
-        if basis_gates is None:
-            basis_gates = target.operation_names
-        if instruction_durations is None:
-            instruction_durations = target.durations()
-        if inst_map is None:
-            inst_map = target.instruction_schedule_map()
-        if timing_constraints is None:
-            timing_constraints = target.timing_constraints()
-        if backend_properties is None:
-            backend_properties = target_to_backend_properties(target)
-
-    pm_options = {
-        "target": target,
-        "basis_gates": basis_gates,
-        "inst_map": inst_map,
-        "coupling_map": coupling_map,
-        "instruction_durations": instruction_durations,
-        "backend_properties": backend_properties,
-        "timing_constraints": timing_constraints,
-        "layout_method": layout_method,
-        "routing_method": routing_method,
-        "translation_method": translation_method,
-        "scheduling_method": scheduling_method,
-        "approximation_degree": approximation_degree,
-        "seed_transpiler": seed_transpiler,
-        "unitary_synthesis_method": unitary_synthesis_method,
-        "unitary_synthesis_plugin_config": unitary_synthesis_plugin_config,
-        "initial_layout": initial_layout,
-        "hls_config": hls_config,
-        "init_method": init_method,
-        "optimization_method": optimization_method,
-    }
-
-    if backend is not None:
-        pm_options["_skip_target"] = _skip_target
-        pm_config = PassManagerConfig.from_backend(backend, **pm_options)
-    else:
-        pm_config = PassManagerConfig(**pm_options)
-    if optimization_level == 0:
-        pm = level_0_pass_manager(pm_config)
-    elif optimization_level == 1:
-        pm = level_1_pass_manager(pm_config)
-    elif optimization_level == 2:
-        pm = level_2_pass_manager(pm_config)
-    elif optimization_level == 3:
-        pm = level_3_pass_manager(pm_config)
-    else:
-        raise ValueError(f"Invalid optimization level {optimization_level}")
-    return pm
-
-
 __all__ = [
     "level_0_pass_manager",
     "level_1_pass_manager",

qiskit/transpiler/preset_passmanagers/builtin_plugins.py

@@ -12,6 +12,9 @@
 
 """Built-in transpiler stage plugins for preset pass managers."""
 
+import os
+
+from qiskit.transpiler.passes.optimization.split_2q_unitaries import Split2QUnitaries
 from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.passes import BasicSwap
@@ -63,6 +66,20 @@ from qiskit.circuit.library.standard_gates import (
     SXGate,
     SXdgGate,
 )
+from qiskit.utils.parallel import CPU_COUNT
+from qiskit import user_config
+
+CONFIG = user_config.get_config()
+
+_discrete_skipped_ops = {
+    "delay",
+    "reset",
+    "measure",
+    "switch_case",
+    "if_else",
+    "for_loop",
+    "while_loop",
+}
 
 
 class DefaultInitPassManager(PassManagerStagePlugin):
@@ -154,6 +171,16 @@ class DefaultInitPassManager(PassManagerStagePlugin):
                 )
             )
             init.append(CommutativeCancellation())
+            init.append(Collect2qBlocks())
+            init.append(ConsolidateBlocks())
+            # If approximation degree is None that indicates a request to approximate up to the
+            # error rates in the target. However, in the init stage we don't yet know the target
+            # qubits being used to figure out the fidelity so just use the default fidelity parameter
+            # in this case.
+            if pass_manager_config.approximation_degree is not None:
+                init.append(Split2QUnitaries(pass_manager_config.approximation_degree))
+            else:
+                init.append(Split2QUnitaries())
         else:
             raise TranspilerError(f"Invalid optimization level {optimization_level}")
         return init
@@ -397,11 +424,12 @@ class SabreSwapPassManager(PassManagerStagePlugin):
             pass_manager_config.initial_layout,
         )
         if optimization_level == 0:
+            trial_count = _get_trial_count(5)
             routing_pass = SabreSwap(
                 coupling_map_routing,
                 heuristic="basic",
                 seed=seed_transpiler,
-                trials=5,
+                trials=trial_count,
             )
             return common.generate_routing_passmanager(
                 routing_pass,
@@ -411,11 +439,12 @@ class SabreSwapPassManager(PassManagerStagePlugin):
                 use_barrier_before_measurement=True,
             )
         if optimization_level == 1:
+            trial_count = _get_trial_count(5)
             routing_pass = SabreSwap(
                 coupling_map_routing,
                 heuristic="decay",
                 seed=seed_transpiler,
-                trials=5,
+                trials=trial_count,
             )
             return common.generate_routing_passmanager(
                 routing_pass,
@@ -429,11 +458,13 @@ class SabreSwapPassManager(PassManagerStagePlugin):
                 use_barrier_before_measurement=True,
             )
         if optimization_level == 2:
+            trial_count = _get_trial_count(20)
+
             routing_pass = SabreSwap(
                 coupling_map_routing,
                 heuristic="decay",
                 seed=seed_transpiler,
-                trials=10,
+                trials=trial_count,
             )
             return common.generate_routing_passmanager(
                 routing_pass,
@@ -446,11 +477,12 @@ class SabreSwapPassManager(PassManagerStagePlugin):
                 use_barrier_before_measurement=True,
             )
         if optimization_level == 3:
+            trial_count = _get_trial_count(20)
             routing_pass = SabreSwap(
                 coupling_map_routing,
                 heuristic="decay",
                 seed=seed_transpiler,
-                trials=20,
+                trials=trial_count,
             )
             return common.generate_routing_passmanager(
                 routing_pass,
@@ -737,12 +769,15 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
                 max_trials=2500,  # Limits layout scoring to < 600ms on ~400 qubit devices
             )
             layout.append(ConditionalController(choose_layout_1, condition=_layout_not_perfect))
+
+            trial_count = _get_trial_count(5)
+
             choose_layout_2 = SabreLayout(
                 coupling_map,
                 max_iterations=2,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=5,
-                layout_trials=5,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
@@ -769,12 +804,15 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
             layout.append(
                 ConditionalController(choose_layout_0, condition=_choose_layout_condition)
             )
+
+            trial_count = _get_trial_count(20)
+
             choose_layout_1 = SabreLayout(
                 coupling_map,
                 max_iterations=2,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=20,
-                layout_trials=20,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
@@ -801,12 +839,15 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
             layout.append(
                 ConditionalController(choose_layout_0, condition=_choose_layout_condition)
             )
+
+            trial_count = _get_trial_count(20)
+
             choose_layout_1 = SabreLayout(
                 coupling_map,
                 max_iterations=4,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=20,
-                layout_trials=20,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
@@ -902,42 +943,50 @@ class SabreLayoutPassManager(PassManagerStagePlugin):
         layout = PassManager()
         layout.append(_given_layout)
         if optimization_level == 0:
+            trial_count = _get_trial_count(5)
+
             layout_pass = SabreLayout(
                 coupling_map,
                 max_iterations=1,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=5,
-                layout_trials=5,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
         elif optimization_level == 1:
+            trial_count = _get_trial_count(5)
+
             layout_pass = SabreLayout(
                 coupling_map,
                 max_iterations=2,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=5,
-                layout_trials=5,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
         elif optimization_level == 2:
+            trial_count = _get_trial_count(20)
+
             layout_pass = SabreLayout(
                 coupling_map,
                 max_iterations=2,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=20,
-                layout_trials=20,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
         elif optimization_level == 3:
+            trial_count = _get_trial_count(20)
+
             layout_pass = SabreLayout(
                 coupling_map,
                 max_iterations=4,
                 seed=pass_manager_config.seed_transpiler,
-                swap_trials=20,
-                layout_trials=20,
+                swap_trials=trial_count,
+                layout_trials=trial_count,
                 skip_routing=pass_manager_config.routing_method is not None
                 and pass_manager_config.routing_method != "sabre",
             )
@@ -957,3 +1006,9 @@ class SabreLayoutPassManager(PassManagerStagePlugin):
         embed = common.generate_embed_passmanager(coupling_map)
         layout.append(ConditionalController(embed.to_flow_controller(), condition=_swap_mapped))
         return layout
+
+
+def _get_trial_count(default_trials=5):
+    if CONFIG.get("sabre_all_threads", None) or os.getenv("QISKIT_SABRE_ALL_THREADS"):
+        return max(CPU_COUNT, default_trials)
+    return default_trials

qiskit/transpiler/preset_passmanagers/common.py

@@ -364,10 +364,7 @@ def generate_routing_passmanager(
         routing.append(ConditionalController(ApplyLayout(), condition=_apply_post_layout_condition))
 
     def filter_fn(node):
-        return (
-            getattr(node.op, "label", None)
-            != "qiskit.transpiler.internal.routing.protection.barrier"
-        )
+        return node.label != "qiskit.transpiler.internal.routing.protection.barrier"
 
     routing.append([FilterOpNodes(filter_fn)])
 
@@ -518,7 +515,7 @@ def generate_translation_passmanager(
             ),
         ]
     else:
-        raise TranspilerError("Invalid translation method %s." % method)
+        raise TranspilerError(f"Invalid translation method {method}.")
     return PassManager(unroll)
 
 
@@ -557,7 +554,7 @@ def generate_scheduling(
         try:
             scheduling.append(scheduler[scheduling_method](instruction_durations, target=target))
         except KeyError as ex:
-            raise TranspilerError("Invalid scheduling method %s." % scheduling_method) from ex
+            raise TranspilerError(f"Invalid scheduling method {scheduling_method}.") from ex
     elif instruction_durations:
         # No scheduling. But do unit conversion for delays.
         def _contains_delay(property_set):