Internal global backend _Global

doc/source/code-examples/advancedexamples.rst

@@ -1261,9 +1261,9 @@ As observable we can simply take :math:`Z_0 Z_1 Z_2` :
 
    from qibo.symbols import Z
    from qibo.hamiltonians import SymbolicHamiltonian
-   from qibo.backends import GlobalBackend
+   from qibo.backends import _Global
 
-   backend = GlobalBackend()
+   backend = _Global.backend()
 
    # Define the observable
    obs = np.prod([Z(i) for i in range(nqubits)])

src/qibo/backends/__init__.py

@@ -65,10 +65,10 @@ def list_available(self) -> dict:
         return available_backends
 
 
-class GlobalBackend(NumpyBackend):
-    """The global backend will be used as default by ``circuit.execute()``."""
+class _Global:
+    _backend = None
+    _transpiler = None
 
-    _instance = None
     _dtypes = {"double": "complex128", "single": "complex64"}
     _default_order = [
         {"backend": "qibojit", "platform": "cupy"},
@@ -78,39 +78,73 @@ class GlobalBackend(NumpyBackend):
         {"backend": "pytorch"},
     ]
 
-    def __new__(cls):
-        if cls._instance is not None:
-            return cls._instance
+    @classmethod
+    def backend(cls):  # pragma: no cover
+        if cls._backend is not None:
+            return cls._backend
 
         backend = os.environ.get("QIBO_BACKEND")
-        if backend:  # pragma: no cover
+        if backend:
             # Create backend specified by user
             platform = os.environ.get("QIBO_PLATFORM")
-            cls._instance = construct_backend(backend, platform=platform)
+            cls._backend = construct_backend(backend, platform=platform)
         else:
             # Create backend according to default order
             for kwargs in cls._default_order:
                 try:
-                    cls._instance = construct_backend(**kwargs)
+                    cls._backend = construct_backend(**kwargs)
                     break
-                except (ImportError, MissingBackend):
+                except (ModuleNotFoundError, ImportError):
                     pass
 
-        if cls._instance is None:  # pragma: no cover
+        if cls._backend is None:
             raise_error(RuntimeError, "No backends available.")
 
-        log.info(f"Using {cls._instance} backend on {cls._instance.device}")
-        return cls._instance
+        log.info(f"Using {cls._backend} backend on {cls._backend.device}")
+        return cls._backend
 
     @classmethod
     def set_backend(cls, backend, **kwargs):  # pragma: no cover
         if (
-            cls._instance is None
-            or cls._instance.name != backend
-            or cls._instance.platform != kwargs.get("platform")
+            cls._backend is None
+            or cls._backend.name != backend
+            or cls._backend.platform != kwargs.get("platform")
         ):
-            cls._instance = construct_backend(backend, **kwargs)
-        log.info(f"Using {cls._instance} backend on {cls._instance.device}")
+            cls._backend = construct_backend(backend, **kwargs)
+            log.info(f"Using {cls._backend} backend on {cls._backend.device}")
+        else:
+            log.info(f"Backend {backend} is already loaded.")
+
+    @classmethod
+    def get_backend(cls):
+        return cls._backend
+
+    @classmethod
+    def transpiler(cls):  # pragma: no cover
+        from qibo.transpiler.pipeline import Passes
+
+        if cls._transpiler is not None:
+            return cls._transpiler
+
+        cls._transpiler = Passes(passes=[])
+        return cls._transpiler
+
+    @classmethod
+    def set_transpiler(cls, transpiler):  # pragma: no cover
+        cls._transpiler = transpiler
+        # TODO: check if transpiler is valid on the backend
+
+    @classmethod
+    def get_transpiler(cls):  # pragma: no cover
+        return cls._transpiler
+
+    @classmethod
+    def resolve_global(cls):
+        if cls._backend is None:
+            cls._backend = cls.backend()
+        if cls._transpiler is None:
+            # TODO: add default transpiler for hardware backends
+            cls._transpiler = cls.transpiler()
 
 
 class QiboMatrices:
@@ -147,24 +181,32 @@ def create(self, dtype):
 
 
 def get_backend():
-    return str(GlobalBackend())
+    return str(_Global.get_backend())
 
 
 def set_backend(backend, **kwargs):
-    GlobalBackend.set_backend(backend, **kwargs)
+    _Global.set_backend(backend, **kwargs)
+
+
+def get_transpiler():
+    return str(_Global.get_transpiler())
+
+
+def set_transpiler(transpiler):
+    _Global.set_transpiler(transpiler)
 
 
 def get_precision():
-    return GlobalBackend().precision
+    return _Global.get_backend().precision
 
 
 def set_precision(precision):
-    GlobalBackend().set_precision(precision)
-    matrices.create(GlobalBackend().dtype)
+    _Global.get_backend().set_precision(precision)
+    matrices.create(_Global.get_backend().dtype)
 
 
 def get_device():
-    return GlobalBackend().device
+    return _Global.get_backend().device
 
 
 def set_device(device):
@@ -174,26 +216,26 @@ def set_device(device):
             ValueError,
             "Device name should follow the pattern: /{device type}:{device number}.",
         )
-    backend = GlobalBackend()
+    backend = _Global.get_backend()
     backend.set_device(device)
     log.info(f"Using {backend} backend on {backend.device}")
 
 
 def get_threads():
-    return GlobalBackend().nthreads
+    return _Global.get_backend().nthreads
 
 
 def set_threads(nthreads):
     if not isinstance(nthreads, int):
         raise_error(TypeError, "Number of threads must be integer.")
     if nthreads < 1:
         raise_error(ValueError, "Number of threads must be positive.")
-    GlobalBackend().set_threads(nthreads)
+    _Global.get_backend().set_threads(nthreads)
 
 
 def _check_backend(backend):
     if backend is None:
-        return GlobalBackend()
+        return _Global.backend()
 
     return backend
 

src/qibo/models/circuit.py

@@ -1099,14 +1099,20 @@ def execute(self, initial_state=None, nshots=1000):
             self._final_state = self.compiled.result(state, nshots)
             return self._final_state
         else:
-            from qibo.backends import GlobalBackend
+            from qibo.backends import _Global
+
+            _Global.resolve_global()
+            transpiler = _Global.get_transpiler()
+            transpiled_circuit, _ = transpiler(self)  # pylint: disable=E1102
 
             if self.accelerators:  # pragma: no cover
-                return GlobalBackend().execute_distributed_circuit(
-                    self, initial_state, nshots
+                return _Global.get_backend().execute_distributed_circuit(
+                    transpiled_circuit, initial_state, nshots
                 )
             else:
-                return GlobalBackend().execute_circuit(self, initial_state, nshots)
+                return _Global.get_backend().execute_circuit(
+                    transpiled_circuit, initial_state, nshots
+                )
 
     def __call__(self, initial_state=None, nshots=1000):
         """Equivalent to ``circuit.execute``."""

src/qibo/models/error_mitigation.py

@@ -7,7 +7,7 @@
 from scipy.optimize import curve_fit
 
 from qibo import gates
-from qibo.backends import GlobalBackend, _check_backend, _check_backend_and_local_state
+from qibo.backends import _check_backend, _check_backend_and_local_state, _Global
 from qibo.config import raise_error
 
 
@@ -1095,8 +1095,9 @@ def _execute_circuit(circuit, qubit_map, noise_model=None, nshots=10000, backend
     from qibo.transpiler.placer import Custom
 
     if backend is None:  # pragma: no cover
-        backend = GlobalBackend()
+        backend = _Global.backend()
     elif backend.name == "qibolab":  # pragma: no cover
+        # TODO: Use _Global.set_transpiler
         backend.transpiler.passes[1] = Custom(
             initial_map=qubit_map, connectivity=backend.platform.topology
         )

tests/test_backends_clifford.py

@@ -8,10 +8,10 @@
 from qibo import Circuit, gates, set_backend
 from qibo.backends import (
     CliffordBackend,
-    GlobalBackend,
     NumpyBackend,
     PyTorchBackend,
     TensorflowBackend,
+    _Global,
 )
 from qibo.backends.clifford import _get_engine_name
 from qibo.noise import DepolarizingError, NoiseModel, PauliError
@@ -36,8 +36,8 @@ def test_set_backend(backend):
     clifford_bkd = construct_clifford_backend(backend)
     platform = _get_engine_name(backend)
     set_backend("clifford", platform=platform)
-    assert isinstance(GlobalBackend(), CliffordBackend)
-    global_platform = GlobalBackend().platform
+    assert isinstance(_Global.get_backend(), CliffordBackend)
+    global_platform = _Global.get_backend().platform
     assert global_platform == platform
 
 
@@ -46,7 +46,9 @@ def test_global_backend(backend):
     set_backend(backend.name, platform=backend.platform)
     clifford_bkd = CliffordBackend()
     target = (
-        GlobalBackend().name if backend.name == "numpy" else GlobalBackend().platform
+        _Global.get_backend().name
+        if backend.name == "numpy"
+        else _Global.get_backend().platform
     )
     assert clifford_bkd.platform == target
     set_backend("numpy")

tests/test_backends_global.py

@@ -1,16 +1,17 @@
+import networkx as nx
 import pytest
 
 import qibo
 from qibo import matrices
 
 
-def test_set_backend():
-    from qibo.backends import GlobalBackend
+def test_set_get_backend():
+    from qibo.backends import _Global
 
-    backend = GlobalBackend()
+    backend = _Global.backend()
     qibo.set_backend("numpy")
     assert qibo.get_backend() == "numpy"
-    assert GlobalBackend().name == "numpy"
+    assert _Global.get_backend().name == "numpy"
 
 
 def test_set_precision():
@@ -104,7 +105,52 @@ def test_check_backend(backend):
     test = None
     test = qibo.backends._check_backend(test)
 
-    target = qibo.backends.GlobalBackend()
+    target = qibo.backends._Global.backend()
 
     assert test.name == target.name
     assert test.__class__ == target.__class__
+
+
+def test_resolve_global():
+    from qibo.backends import _Global
+
+    _Global._backend = None
+    _Global._transpiler = None
+
+    assert _Global._backend is None
+    assert _Global._transpiler is None
+    _Global.resolve_global()
+    assert issubclass(_Global._backend.__class__, qibo.backends.Backend)
+    assert _Global._transpiler is not None
+
+
+def _star_connectivity():
+    Q = [i for i in range(5)]
+    chip = nx.Graph()
+    chip.add_nodes_from(Q)
+    graph_list = [(Q[i], Q[2]) for i in range(5) if i != 2]
+    chip.add_edges_from(graph_list)
+    return chip
+
+
+def test_set_get_transpiler():
+    from qibo.backends import _Global
+    from qibo.transpiler.optimizer import Preprocessing
+    from qibo.transpiler.pipeline import Passes
+    from qibo.transpiler.placer import Random
+    from qibo.transpiler.router import Sabre
+    from qibo.transpiler.unroller import NativeGates, Unroller
+
+    connectivity = _star_connectivity()
+    transpiler = Passes(
+        connectivity=connectivity,
+        passes=[
+            Preprocessing(connectivity),
+            Random(connectivity, seed=0),
+            Sabre(connectivity),
+            Unroller(NativeGates.default()),
+        ],
+    )
+
+    _Global.set_transpiler(transpiler)
+    assert _Global.get_transpiler() == transpiler

tests/test_backends_qibotn.py

@@ -1,16 +1,18 @@
 import os
 
 import qibo
+from qibo.backends import _Global
 
 # Force quimb to use qibojit default number of threads.
+_Global.backend()
 os.environ["NUMBA_NUM_THREADS"] = f"{qibo.get_threads()}"
 from qibotn.backends.quimb import QuimbBackend
 
-from qibo.backends import GlobalBackend
+from qibo.backends import _Global
 
 
 def test_backend_qibotn():
     qibo.set_backend(backend="qibotn", platform="qutensornet", runcard=None)
-    assert isinstance(GlobalBackend(), QuimbBackend)
+    assert isinstance(_Global.get_backend(), QuimbBackend)
 
     qibo.set_backend("numpy")

tests/test_backends_qulacs.py

@@ -4,7 +4,7 @@
 import pytest
 
 from qibo import Circuit, gates
-from qibo.backends import GlobalBackend, MetaBackend, NumpyBackend, set_backend
+from qibo.backends import MetaBackend, NumpyBackend, _Global, set_backend
 from qibo.quantum_info import random_clifford, random_density_matrix, random_statevector
 
 numpy_bkd = NumpyBackend()
@@ -40,4 +40,4 @@ def test_initial_state_error():
 
 def test_set_backend():
     set_backend("qulacs")
-    assert GlobalBackend().name == "qulacs"
+    assert _Global.get_backend().name == "qulacs"