Merge branch 'v0.31.0_rc' into qemu_git_ownership

Author: vincentmr

.github/CHANGELOG.md

@@ -109,8 +109,7 @@ jobs:
       - name: Install lightning.qubit device
         run: |
           cd main
-          python setup.py build_ext -i --define="ENABLE_KOKKOS=OFF;ENABLE_PYTHON=ON;CMAKE_CXX_COMPILER=$(which g++-$GCC_VERSION)"
-          pip install -e .
+          CMAKE_ARGS="-DENABLE_KOKKOS=OFF -DENABLE_PYTHON=ON -DCMAKE_CXX_COMPILER=$(which g++-$GCC_VERSION)" pip install -e . -vv
 
       - name: Run PennyLane-Lightning unit tests
         run: |
@@ -227,8 +226,7 @@ jobs:
       - name: Install lightning.qubit device
         run: |
           cd main
-          python setup.py build_ext -i --define="ENABLE_BLAS=ON;ENABLE_KOKKOS=OFF;ENABLE_PYTHON=ON;CMAKE_CXX_COMPILER=$(which g++-$GCC_VERSION)"
-          pip install -e .
+          CMAKE_ARGS="-DENABLE_BLAS=ON -DENABLE_KOKKOS=OFF -DCMAKE_CXX_COMPILER=$(which g++-$GCC_VERSION)" pip install -e . -vv
 
       - name: Run PennyLane-Lightning unit tests
         run: |
@@ -382,8 +380,7 @@ jobs:
       - name: Install lightning.qubit device
         run: |
           cd main
-          python setup.py build_ext -i --define="CMAKE_PREFIX_PATH=${{ github.workspace }}/Kokkos;ENABLE_KOKKOS=ON;ENABLE_PYTHON=ON;CMAKE_CXX_COMPILER=$(which g++-$GCC_VERSION)"
-          pip install -e .
+          CMAKE_ARGS="-DCMAKE_PREFIX_PATH=${{ github.workspace }}/Kokkos -DCMAKE_CXX_COMPILER=$(which g++-$GCC_VERSION)" pip install -e . -vv
 
       - name: Run PennyLane-Lightning unit tests
         run: |
@@ -531,8 +528,7 @@ jobs:
       - name: Install lightning.qubit device
         run: |
           cd main
-          python setup.py build_ext -i --define="ENABLE_BLAS=ON;ENABLE_KOKKOS=ON;DENABLE_PYTHON=ON;CMAKE_PREFIX_PATH=${{ github.workspace }}/Kokkos;CMAKE_CXX_COMPILER=$(which g++-$GCC_VERSION)"
-          pip install -e .
+          CMAKE_ARGS="-DENABLE_BLAS=ON -DCMAKE_PREFIX_PATH=${{ github.workspace }}/Kokkos -DCMAKE_CXX_COMPILER=$(which g++-$GCC_VERSION)" pip install -e . -vv
 
       - name: Run PennyLane-Lightning unit tests
         run: |

.github/workflows/tests_linux.yml

@@ -170,7 +170,8 @@ jobs:
             yum install devtoolset-11-gcc-c++ -y
             source /opt/rh/devtoolset-11/enable -y
 
-          CIBW_ENVIRONMENT: PATH=/opt/rh/devtoolset-11/root/usr/bin:$PATH
+          CIBW_ENVIRONMENT: |
+            PATH=/opt/rh/devtoolset-11/root/usr/bin:$PATH
           # Testing of built wheels
           CIBW_TEST_REQUIRES: pytest pytest-cov pytest-mock flaky
 

.github/workflows/wheel_linux_x86_64.yml

@@ -89,6 +89,9 @@ jobs:
           CIBW_BEFORE_BUILD: |
             pip install pybind11 ninja cmake~=3.24.0 setuptools
 
+          CIBW_ENVIRONMENT: |
+            CMAKE_ARGS="-DCMAKE_CXX_COMPILER_TARGET=arm64-apple-macos11 -DCMAKE_SYSTEM_NAME=Darwin -DCMAKE_SYSTEM_PROCESSOR=ARM64 -DENABLE_OPENMP=OFF"
+
           # Testing of built wheels
           CIBW_TEST_REQUIRES: pytest pytest-cov pytest-mock flaky
 

.github/workflows/wheel_macos_arm64.yml

@@ -174,8 +174,6 @@ jobs:
 
           CIBW_ARCHS_MACOS: ${{matrix.arch}}
 
-          USE_OMP: 1
-
         run: |
           python -m cibuildwheel --output-dir wheelhouse
 

.github/workflows/wheel_macos_x86_64.yml

@@ -45,7 +45,12 @@ option(ENABLE_CLANG_TIDY "Enable clang-tidy build checks" OFF)
 option(ENABLE_COVERAGE "Enable code coverage" OFF)
 option(ENABLE_WARNINGS "Enable warnings" ON)
 option(ENABLE_NATIVE "Enable native CPU build tuning" OFF)
-option(ENABLE_OPENMP "Enable OpenMP" ON)
+find_package(OpenMP)
+if (OpenMP_CXX_FOUND)
+    option(ENABLE_OPENMP "Enable OpenMP" ON)
+else()
+    option(ENABLE_OPENMP "Enable OpenMP" OFF)
+endif()
 option(ENABLE_KOKKOS "Enable Kokkos" ON)
 option(ENABLE_BLAS "Enable BLAS" OFF)
 option(ENABLE_PYTHON "Enable compilation of the Python module" ON)

CMakeLists.txt

@@ -67,13 +67,19 @@ To build PennyLane-Lightning from source you can run
 
     $ pip install pybind11 pennylane-lightning --no-binary :all:
 
-A C++ compiler such as ``g++``, ``clang``, or ``MSVC`` is required. On Debian-based systems, this
-can be installed via ``apt``:
+A C++ compiler such as ``g++``, ``clang++``, or ``MSVC`` is required.
+On Debian-based systems, this can be installed via ``apt``:
 
 .. code-block:: console
 
     $ sudo apt install g++
 
+On MacOS, we recommend using the latest version of ``clang++`` and ``libomp``:
+
+.. code-block:: console
+
+    $ brew install llvm libomp
+
 The `pybind11 <https://pybind11.readthedocs.io/en/stable/>`_ library is also used for binding the
 C++ functionality to Python.
 
@@ -89,23 +95,25 @@ Alternatively, for development and testing, you can install by cloning the repos
 Note that subsequent calls to ``pip install -e .`` will use cached binaries stored in the
 ``build`` folder. Run ``make clean`` if you would like to recompile.
 
-You can also pass ``cmake`` options with ``build_ext``:
+You can also pass ``cmake`` options with ``CMAKE_ARGS`` as follows:
 
 .. code-block:: console
 
-    $ python3 setup.py build_ext -i --define="ENABLE_OPENMP=OFF;ENABLE_NATIVE=ON"
+    $ CMAKE_ARGS="-DENABLE_OPENMP=OFF -DENABLE_BLAS=OFF -DENABLE_KOKKOS=OFF" pip install -e . -vv
 
-and install the compiled library with
+or with ``build_ext`` and the ``--define`` flag as follows:
 
 .. code-block:: console
 
+    $ python3 setup.py build_ext -i --define="ENABLE_OPENMP=OFF;ENABLE_BLAS=OFF;ENABLE_KOKKOS=OFF"
     $ python3 setup.py develop
 
 
 GPU support
 -----------
 
-For GPU support, `PennyLane-Lightning-GPU <https://github.com/PennyLaneAI/pennylane-lightning-gpu>`_ can be installed by providing the optional ``[gpu]`` tag:
+For GPU support, `PennyLane-Lightning-GPU <https://github.com/PennyLaneAI/pennylane-lightning-gpu>`_
+can be installed by providing the optional ``[gpu]`` tag:
 
 .. code-block:: console
 
@@ -148,18 +156,26 @@ To test the C++ code:
     $ cmake -DBUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug ..
     $ make
 
-Other supported options are ``-DENABLE_WARNINGS=ON``,
-``-DENABLE_NATIVE=ON`` (for ``-march=native``),
-``-DENABLE_BLAS=ON``, ``-DENABLE_OPENMP=ON``,
-``-DENABLE_KOKKOS=ON``, and ``-DENABLE_CLANG_TIDY=ON``.
+Other supported options are
+
+- ``-DENABLE_WARNINGS=ON``
+- ``-DENABLE_NATIVE=ON`` (for ``-march=native``)
+- ``-DENABLE_BLAS=ON``
+- ``-DENABLE_OPENMP=ON``
+- ``-DENABLE_KOKKOS=ON``
+- ``-DENABLE_CLANG_TIDY=ON``
 
 Compile on Windows with MSVC
 ----------------------------
 
-You can also compile Pennylane-Lightning on Windows using `Microsoft Visual C++ <https://visualstudio.microsoft.com/vs/features/cplusplus/>`_ compiler. You need `cmake <https://cmake.org/download/>`_ and appropriate Python environment (e.g. using `Anaconda <https://www.anaconda.com/>`_).
+You can also compile Pennylane-Lightning on Windows using
+`Microsoft Visual C++ <https://visualstudio.microsoft.com/vs/features/cplusplus/>`_ compiler.
+You need `cmake <https://cmake.org/download/>`_ and appropriate Python environment
+(e.g. using `Anaconda <https://www.anaconda.com/>`_).
 
 
-We recommend to use ``[x64 (or x86)] Native Tools Command Prompt for VS [version]`` for compiling the library. Be sure that ``cmake`` and ``python`` can be called within the prompt.
+We recommend to use ``[x64 (or x86)] Native Tools Command Prompt for VS [version]`` for compiling the library.
+Be sure that ``cmake`` and ``python`` can be called within the prompt.
 
 
 .. code-block:: console

README.rst

@@ -17,4 +17,4 @@
 """
 
 
-__version__ = "0.31.0-dev6"
+__version__ = "0.31.0-rc1"

pennylane_lightning/_version.py

@@ -166,14 +166,14 @@ class LightningQubit(QubitDevice):
             random qubit site and then generates a random number to determine the new bit at that qubit site. The ``"NonZeroRandom"`` kernel
             randomly transits between states that have nonzero probability.
         num_burnin (int): number of steps that will be dropped. Increasing this value will
-        result in a closer approximation but increased runtime.
+            result in a closer approximation but increased runtime.
         batch_obs (bool): Determine whether we process observables parallelly when computing the
             jacobian. This value is only relevant when the lightning qubit is built with OpenMP.
     """
 
     name = "Lightning Qubit PennyLane plugin"
     short_name = "lightning.qubit"
-    pennylane_requires = ">=0.26"
+    pennylane_requires = ">=0.30"
     version = __version__
     author = "Xanadu Inc."
     _CPP_BINARY_AVAILABLE = True
@@ -979,7 +979,7 @@ def _get_diagonalizing_gates(self, circuit: qml.tape.QuantumTape) -> List[Operat
     class LightningQubit(DefaultQubit):  # pragma: no cover
         name = "Lightning Qubit PennyLane plugin"
         short_name = "lightning.qubit"
-        pennylane_requires = ">=0.26"
+        pennylane_requires = ">=0.30"
         version = __version__
         author = "Xanadu Inc."
         _CPP_BINARY_AVAILABLE = False

pennylane_lightning/lightning_qubit.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 import os
 import platform
-import sys
 import subprocess
 import shutil
 from pathlib import Path
@@ -32,32 +31,32 @@ class CMakeBuild(build_ext):
     This class is built upon https://github.com/diegoferigo/cmake-build-extension/blob/master/src/cmake_build_extension/build_extension.py and https://github.com/pybind/cmake_example/blob/master/setup.py
     """
 
-    user_options = build_ext.user_options + [
-        ("define=", "D", "Define variables for CMake")
-    ]
+    user_options = build_ext.user_options + [("define=", "D", "Define variables for CMake")]
 
     def initialize_options(self):
         super().initialize_options()
         self.define = None
+        self.verbosity = ""
 
     def finalize_options(self):
         # Parse the custom CMake options and store them in a new attribute
         defines = [] if self.define is None else self.define.split(";")
         self.cmake_defines = [f"-D{define}" for define in defines]
+        if self.verbosity != "":
+            self.verbosity = "--verbose"
 
         super().finalize_options()
 
     def build_extension(self, ext: CMakeExtension):
         extdir = str(Path(self.get_ext_fullpath(ext.name)).parent.absolute())
-
         debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug
+        build_type = "Debug" if debug else "RelWithDebInfo"
         ninja_path = str(shutil.which("ninja"))
 
-        # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON
+        build_args = ["--config", "Debug"] if debug else ["--config", "RelWithDebInfo"]
         configure_args = [
             f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}",
-            f"-DPython_EXECUTABLE={sys.executable}",  # (Windows)
-            f"-DPYTHON_EXECUTABLE={sys.executable}",  # (Ubuntu)
+            f"-DCMAKE_BUILD_TYPE={build_type}",  # not used on MSVC, but no harm
             "-DENABLE_WARNINGS=OFF",  # Ignore warnings
         ]
 
@@ -73,88 +72,47 @@ def build_extension(self, ext: CMakeExtension):
                 f"-DCMAKE_MAKE_PROGRAM={ninja_path}",
             ]
 
-        build_args = []
-
-        if debug:
-            configure_args += ["-DCMAKE_BUILD_TYPE=Debug"]
-            build_args += ["--config", "Debug"]
-        else:
-            build_args += ["--config", "RelWithDebInfo"]
-
         configure_args += self.cmake_defines
 
         # Add more platform dependent options
         if platform.system() == "Darwin":
-            # To support ARM64
-            if os.getenv("ARCHS") == "arm64":
-                configure_args += [
-                    "-DCMAKE_CXX_COMPILER_TARGET=arm64-apple-macos11",
-                    "-DCMAKE_SYSTEM_NAME=Darwin",
-                    "-DCMAKE_SYSTEM_PROCESSOR=ARM64",
-                    "-DENABLE_OPENMP=OFF",
-                ]
-            else:  # X64 arch
-                # If we explicitly request a brew LLVM version, use that
-                if os.getenv("BREW_LLVM_VERSION") and shutil.which("brew"):
-                    brew_llvm_version = os.getenv("BREW_LLVM_VERSION")
-                    llvmpath = subprocess.run(
-                        [
-                            "brew",
-                            "--prefix",
-                            "llvm" + f"@{brew_llvm_version}"
-                            if brew_llvm_version
-                            else "",
-                        ],
-                        check=True,
-                        capture_output=True,
-                        text=True,
-                    ).stdout.strip()
-
-                else:
-                    # No brew, use the default clang++ install provided by MacOS
-                    llvmpath = shutil.which("clang++")
-                    llvmpath = Path(llvmpath).parent.parent
-
-                # Ensure the appropriate compiler and linker are chosen
-                configure_args += [
-                    f"-DCMAKE_CXX_COMPILER={llvmpath}/bin/clang++",
-                    f"-DCMAKE_LINKER={llvmpath}/bin/lld",
-                ]  # Use clang instead of appleclang
-
-                # Try to support OpenMP through libomp if available
-                if os.environ.get("USE_OMP") and shutil.which("brew"):
-                    libomp_path = subprocess.run(
-                        [
-                            "brew",
-                            "--prefix",
-                            "libomp",
-                        ],
-                        check=False,
-                        capture_output=True,
-                        text=True,
-                    ).stdout.strip()
-                    configure_args += (
-                        [f"-DOpenMP_ROOT={libomp_path}/"]
-                        if libomp_path
-                        else ["-DENABLE_OPENMP=OFF"]
-                    )
+            clang_path = Path(shutil.which("clang++")).parent.parent
+            configure_args += [
+                f"-DCMAKE_CXX_COMPILER={clang_path}/bin/clang++",
+                f"-DCMAKE_LINKER={clang_path}/bin/lld",
+            ]
+            if shutil.which("brew"):
+                libomp_path = subprocess.run(
+                    "brew --prefix libomp".split(" "),
+                    check=False,
+                    capture_output=True,
+                    text=True,
+                ).stdout.strip()
+                if not Path(libomp_path).exists():
+                    libomp_path = ""
+                configure_args += (
+                    [f"-DOpenMP_ROOT={libomp_path}/"] if libomp_path else ["-DENABLE_OPENMP=OFF"]
+                )
         elif platform.system() == "Windows":
             configure_args += ["-DENABLE_OPENMP=OFF", "-DENABLE_BLAS=OFF"]
-        elif platform.system() != "Linux":
+        elif platform.system() not in ["Linux"]:
             raise RuntimeError(f"Unsupported '{platform.system()}' platform")
 
         if not Path(self.build_temp).exists():
             os.makedirs(self.build_temp)
 
-        subprocess.run(
+        if "CMAKE_ARGS" in os.environ.keys():
+            configure_args += os.environ["CMAKE_ARGS"].split(" ")
+
+        subprocess.check_call(
             ["cmake", str(ext.sourcedir)] + configure_args,
             cwd=self.build_temp,
-            check=True,
+            env=os.environ,
         )
-        subprocess.run(
+        subprocess.check_call(
             ["cmake", "--build", ".", "--verbose"] + build_args,
             cwd=self.build_temp,
-            check=True,
+            env=os.environ,
         )
 
 
@@ -190,9 +148,9 @@ def build_extension(self, ext: CMakeExtension):
     "long_description_content_type": "text/x-rst",
     "provides": ["pennylane_lightning"],
     "install_requires": requirements,
-    "ext_modules": [CMakeExtension("lightning_qubit_ops")]
-    if not os.environ.get("SKIP_COMPILATION", False)
-    else [],
+    "ext_modules": []
+    if os.environ.get("SKIP_COMPILATION", False)
+    else [CMakeExtension("lightning_qubit_ops")],
     "cmdclass": {"build_ext": CMakeBuild},
     "ext_package": "pennylane_lightning",
     "extras_require": {"gpu": ["pennylane-lightning-gpu"]},