Splitting matrix operations, refactor dispatcher, add a benchmark suite for all gates/generators/matrices

.github/CHANGELOG.md

@@ -6,6 +6,9 @@
 
 ### Improvements
 
+* Split matrix operations, refactor dispatch mechanisms, and add a benchmark suits.
+[(#274)](https://github.com/PennyLaneAI/pennylane-lightning/pull/274)
+
 ### Documentation
 
 * Use the centralized [Xanadu Sphinx Theme](https://github.com/XanaduAI/xanadu-sphinx-theme)
@@ -18,7 +21,7 @@
 
 This release contains contributions from (in alphabetical order):
 
-Mikhail Andrenkov
+Mikhail Andrenkov, Chae-Yeun Park
 
 ---
 

.github/workflows/format.yml

@@ -22,7 +22,7 @@ jobs:
       - name: Install dependencies
         run:
             python -m pip install --upgrade pip
-            pip install black
+            pip install click==8.0.4 black
 
       - uses: actions/checkout@v2
 

.github/workflows/tests_linux.yml

@@ -159,10 +159,9 @@ jobs:
       - name: Build and run gbenchmark
         run: |
             cmake pennylane_lightning/src/ -BBuildGBench -DBUILD_BENCHMARKS=ON -DENABLE_BLAS=ON -DCMAKE_BUILD_TYPE=Release
-            cmake --build ./BuildGBench --target utils apply_operations apply_multirz
+            cmake --build ./BuildGBench
             ./BuildGBench/benchmarks/utils
             ./BuildGBench/benchmarks/apply_operations
-            ./BuildGBench/benchmarks/apply_multirz
 
   pythontests:
     name: Python tests

.gitignore

@@ -4,6 +4,7 @@ PennyLane_Lightning.egg-info/
 build/
 Build/
 BuildBench/
+BuildGBench/
 BuildTests/
 dist/
 tests/__pycache__/
@@ -19,6 +20,7 @@ doc/code/
 cpptests
 *.o
 
+.cache/*
 .vscode/*
 .ycm_extra_conf.py
 /.vs

Makefile

@@ -92,18 +92,11 @@ test-cpp-omp:
 	cmake --build ./BuildTests --target runner
 	cmake --build ./BuildTests --target test
 
-.PHONY: benchmark
-benchmark:
-	cmake --build BuildBench --target clean || true
-	rm -rf ./BuildBench/CMakeCache.txt ./BuildBench/compiler_info.txt ./BuildBench/run_gate_benchmark.sh
-	cmake $(LIGHTNING_CPP_DIR) -BBuildBench -DBUILD_EXAMPLES=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_AVX=ON
-	cmake --build ./BuildBench
-
 .PHONY: gbenchmark
 gbenchmark:
 	rm -rf ./BuildGBench
 	cmake $(LIGHTNING_CPP_DIR) -BBuildGBench -DBUILD_BENCHMARKS=ON -DENABLE_OPENMP=ON -DENABLE_BLAS=ON -DCMAKE_BUILD_TYPE=Release
-	cmake --build ./BuildGBench --target utils apply_operations apply_multirz
+	cmake --build ./BuildGBench 
 
 .PHONY: format format-cpp format-python
 format: format-cpp format-python
@@ -125,5 +118,5 @@ endif
 .PHONY: check-tidy
 check-tidy:
 	rm -rf ./Build
-	cmake . -BBuild -DENABLE_CLANG_TIDY=ON -DBUILD_TESTS=ON -DBUILD_EXAMPLES=ON
-	cmake --build ./Build
+	cmake . -BBuild -DENABLE_CLANG_TIDY=ON -DBUILD_TESTS=ON
+	cmake --build ./Build

doc/add_kernel.rst

@@ -62,16 +62,6 @@ Now you can call your kernel functions in C++.
     // call using the dynamic dispatcher
     sv.applyOperation(KernelType::MyKernel, "PauliX", /*wires=*/{0}, /*inverse=*/false);
 
-To export your gate implementation to python, you also need to add your kernel to ``kernels_to_pyexport``:
-
-.. code-block:: cpp
-
-    // file: simulator/KernelType.hpp
-    [[maybe_unused]] constexpr std::array kernels_to_pyexport = {
-        KernelType::PI, KernelType::LM, KernelType::Mykernel /* This is added */
-    };
-
-Then you can find ``PauliX_MyKernel`` function in ``lightning_qubit_ops`` Python module.
 
 Still, note that your gate implementation is not a default implementation for ``PauliX`` gate yet, i.e.,
 
@@ -84,7 +74,7 @@ To make your gate implementation default, you need to change ``default_kernel_fo
 
 .. code-block:: cpp
 
-    // file: simulator/Constant.hpp
+    // file: gates/Constant.hpp
     constexpr std::array default_kernel_for_gates = {
         std::pair{GateOperations::PauliX, KernelType::LM},
         std::pair{GateOperations::PauliY, KernelType::LM},

doc/benchmark.rst

@@ -5,36 +5,43 @@ You can benchmark different gate implementations inside the project.
 
 .. code-block:: console
 
-    $ make benchmark
-    $ cd BuildBench
+    $ make gbenchmark
+    $ cd BuildGBench
 
-Inside the directory, you can see ``run_gate_benchmark.sh``. You can benchmark a specific kernel implementation for a gate by providing arguments. 
-Currently, we have two different kernels in ``Pennylane-Lightning`` named ``PI`` and ``LM``. For difference between two kernels, see the documents :cpp:class:`Pennylane::GateOperationsPI` and :cpp:class:`Pennylane::GateOperationsLM`.
-For example, you can compare benchmark results for ``PauliX`` gate with ``KernelType::PI`` and ``KernelType::LM`` by running the following commands:
+Then you can benchmark all gate operations in all kernels by running the script.
 
 .. code-block:: console
 
-    $ ./run_gate_benchmark.sh PI PauliX
-    $ ./run_gate_benchmark.sh LM PauliX
-
-The benchmark results will be written in ``res_{COMPILER}_{VERSION}`` subdirectory. For example, if you use GCC version 9.3.0, the directory name will be ``res_GNU_9.3.0``. 
+    $ ./benchmarks/benchmark_all.sh
 
+The results will be recorded in ``bench_result.json`` file.
 You can then plot the results for a specific gate with 
 
 .. code-block:: console
 
-    $ ./plot_gate_benchmark res_GNU_9.3.0 PauliX
+    $ ./benchmarks/plot_gate_benchmark.py ./bench_result.json
+
+It will create a plot for each gate operation comparing performance of kernels and floating point types. The plots can be found in ``plots`` subdirectory.
+
+One can also choose a specific datatype by providing an option:
+
+.. code-block:: console
+
+    $ ./benchmarks/plot_gate_benchmark.py --precision float ./bench_result.json # Results for std::complex<float>
+    $ ./benchmarks/plot_gate_benchmark.py --precision double ./bench_result.json # Results for std::complex<double>
+
+
+Currently, we have two different kernels in ``Pennylane-Lightning`` named ``PI`` and ``LM``. For difference between two kernels, see the documents :cpp:class:`Pennylane::Gates::GateImplementationsPI` and :cpp:class:`Pennylane::Gates::GateImplementationsLM`.
 
-You should change the second argument to your result directory name. Example outputs are as below:
+Here are some example plots:
 
-.. image:: ./_static/benchmark/plot_PauliX.png
+.. image:: ./_static/benchmark/PauliX.png
    :width: 600
    :alt: Benchmark result for PauliX gate
    :align: center
 
-.. image:: ./_static/benchmark/plot_RX.png
+.. image:: ./_static/benchmark/RX.png
    :width: 600
    :alt: Benchmark result for RX gate
    :align: center
 
-It shows the LM kernel is :math:`\sim 2` times faster for the PauliX gate (for all number of qubits :math:`N`) but is slightly slower for the RX gate when :math:`N \leq 22`.

pennylane_lightning/_serialize.py

@@ -38,24 +38,11 @@
         ObsStructC64,
         StateVectorC128,
         ObsStructC128,
-        DEFAULT_KERNEL_FOR_OPS,
     )
 except ImportError:
     pass
 
 
-def _is_lightning_gate(gate_name):
-    """Returns True if the gate (besides Matrix) is implemented
-    and exported from lightning.
-
-    Args:
-        gate_name (str): the name of gate
-    """
-    if gate_name == "Matrix":
-        return False
-    return gate_name in DEFAULT_KERNEL_FOR_OPS
-
-
 def _obs_has_kernel(obs: Observable) -> bool:
     """Returns True if the input observable has a supported kernel in the C++ backend.
 
@@ -171,7 +158,7 @@ def _serialize_ops(
             name = single_op.name if not is_inverse else single_op.name[:-4]
             names.append(name)
 
-            if not _is_lightning_gate(name):
+            if not hasattr(StateVectorC128, name):
                 params.append([])
                 mats.append(qml.matrix(single_op))
 

pennylane_lightning/_version.py

@@ -16,4 +16,4 @@
    Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.24.0-dev4"
+__version__ = "0.24.0-dev5"

pennylane_lightning/lightning_qubit.py

@@ -54,11 +54,9 @@
         StateVectorC128,
         AdjointJacobianC128,
         VectorJacobianProductC128,
-        DEFAULT_KERNEL_FOR_OPS,
-        EXPORTED_KERNEL_OPS,
     )
 
-    from ._serialize import _serialize_obs, _serialize_ops, _is_lightning_gate
+    from ._serialize import _serialize_obs, _serialize_ops
 
     CPP_BINARY_AVAILABLE = True
 except ModuleNotFoundError:
@@ -98,9 +96,6 @@ class LightningQubit(DefaultQubit):
 
     Args:
         wires (int): the number of wires to initialize the device with
-        kernel_for_ops (dict): Optional argument which kernel to run for a gate operation.
-            For example, if {'PauliX': 'LM', 'RX': 'PI'} is passed, the less memory (LM) kernel
-            is used for PauliX whereas precomputed indices (PI) kernel is used for RX.
         shots (int): How many times the circuit should be evaluated (or sampled) to estimate
             the expectation values. Defaults to ``None`` if not specified. Setting
             to ``None`` results in computing statistics like expectation values and
@@ -115,19 +110,7 @@ class LightningQubit(DefaultQubit):
     _CPP_BINARY_AVAILABLE = True
     operations = _remove_snapshot_from_operations(DefaultQubit.operations)
 
-    def __init__(self, wires, *, kernel_for_ops=None, shots=None, batch_obs=False):
-        self._kernel_for_ops = DEFAULT_KERNEL_FOR_OPS
-        if kernel_for_ops is not None:
-            if not isinstance(kernel_for_ops, dict):
-                raise ValueError("Argument kernel_for_ops must be a dictionary.")
-
-            for gate_op, kernel in kernel_for_ops.items():
-                if (kernel, gate_op) not in EXPORTED_KERNEL_OPS:
-                    raise ValueError(
-                        f"The given kernel {kernel} does not implement {gate_op} gate."
-                    )
-                self._kernel_for_ops[gate_op] = kernel
-
+    def __init__(self, wires, *, shots=None, batch_obs=False):
         super().__init__(wires, shots=shots)
         self._batch_obs = batch_obs
 
@@ -211,17 +194,13 @@ def apply_lightning(self, state, operations, dtype=np.complex128):
             if o.base_name in skipped_ops:
                 continue
             name = o.name.split(".")[0]  # The split is because inverse gates have .inv appended
-            if _is_lightning_gate(name):
-                kernel = self._kernel_for_ops[name]
-                method = getattr(sim, f"{name}_{kernel}".format(), None)
-            else:
-                method = None
+            method = getattr(sim, name, None)
 
             wires = self.wires.indices(o.wires)
 
             if method is None:
                 # Inverse can be set to False since qml.matrix(o) is already in inverted form
-                method = getattr(sim, "applyMatrix_{}".format(self._kernel_for_ops["Matrix"]))
+                method = getattr(sim, "applyMatrix")
                 try:
                     method(qml.matrix(o), wires, False)
                 except AttributeError:  # pragma: no cover