Skip to content

11. Quantum Computing

This chapter introduces the GPU-based quantum circuit simulation resources provided by the computing platform, as well as how to apply for a cluster account and submit simulator jobs.

11.1 High-Performance GPU Simulator

This section mainly describes high-performance GPU simulators for quantum circuits deployed on the IHEP V100 GPU cluster, such as the Qiskit GPU simulator (qiskit-aer). The simulator supports MPI-based multi-GPU parallelism.

11.2 Cluster Account and Login

Users Without an IHEP Cluster Account

Refer toSection 4.1.1 Unified Authentication Accountto register an IHEP unified authentication account, then apply for a cluster AFS account. SelectQCin theAffiliated Applicationfield and fill in the other information according to your actual situation.

Users With an Existing IHEP Cluster Account

If you already have an IHEP cluster account but do not belong to theQCuser group, apply for a secondary group according toSection 4.1.3 Apply to Add a Secondary Group.

Log in tohttps://ink.ihep.ac.cn, then go toDashboard→Apply for second linux group→Secondary group applyand select theQCsecondary group.

After the application is approved, a user directory will be created under/hpcfs/quantum/on the cluster.

11.3 Simulator Job Submission

Software Environment

Usemoduleto manage software environments such as MPI compilers and quantum simulators:

moduleuse/hpcfs/quantum/modulefilesmoduleav

The command above shows available software and versions. Usemodule loadto load the corresponding software. For example,module load quantum/qiskit-2.4.1-aer-gpuloads the IBM Qiskit quantum programming framework. Through theqiskit-aerbackend, it supports high-performance GPU simulation and can use MPI for multi-GPU simulation of quantum circuits that exceed the memory of a single GPU.

module load quantum/pennylane-lightning-0.45.0loads Xanadu's PennyLane simulator, which is well suited for quantum machine learning research. It provides the high-performance C++-based CPU simulatorlightning.qubit, the NVIDIA cuQuantum-based GPU simulatorlightning.gpu, and the Kokkos-based cross-platform GPU simulatorlightning.kokkos, with support for MPI acceleration across multiple GPUs and multiple nodes.

Slurm Job Submission

When submitting quantum simulation jobs through Slurm, usegpuforpartition,qcforaccount, andqcnormalforqos.

Qiskit Simulator

An example Slurm job script (which can be namedsubmit.sh) is shown below:

#!/bin/bash#SBATCH --partition=gpu#SBATCH --qos=qcnormal#SBATCH --account=qc#SBATCH --job-name=qv#SBATCH --output=qv.%j.out#SBATCH --error=qv.%j.err#SBATCH --nodes=1#SBATCH --gres=gpu:v100:1#SBATCH --ntasks=1#SBATCH --mem=40Gmodulepurgemoduleuse/hpcfs/quantum/modulefilesmoduleloadquantum/qiskit-2.4.1-aer-gpuexportOMP_NUM_THREADS=1ulimit-sunlimitedecho"Slurm job ID:$SLURM_JOB_ID"echo"Slurm job partition:$SLURM_JOB_PARTITION"echo"Slurm job account:$SLURM_JOB_ACCOUNT"echo"Slurm job nodes:$SLURM_JOB_NODELIST"pythoncompare_cpu_gpu.py--qubits-min10--qubits-max25

compare_cpu_gpu.pycompares the performance of Qiskit'sQuantumVolumequantum circuit on CPU and GPU for different numbers of qubits. The script is as follows:

"""Compare CPU vs Thrust GPU simulation time on Quantum Volume circuits."""from__future__importannotationsimportargparsefromqiskitimporttranspilefromqiskit.circuitimportQuantumCircuitfromqiskit.circuit.libraryimportquantum_volumefromqiskit_aerimportAerSimulatorOUTPUT="compare_cpu_gpu.png"SEED=12345BACKENDS=(("CPU"," dc2626","s"),("GPU"," 2563eb","o"),)defmake_circuit(qubits:int,depth:int)->QuantumCircuit:circuit=quantum_volume(qubits,depth,seed=0)circuit.measure_all()returncircuitdefrun_benchmark(qubits:int,device:str,*,depth:int,shots:int)->float:sim=AerSimulator(method="statevector",device=device)circuit=transpile(make_circuit(qubits,depth),sim)result=sim.run(circuit,shots=shots,seed_simulator=SEED).result()data=result.to_dict()["results"][0]ifdata.get("status")!="DONE":raiseRuntimeError(f"{device}failed at{qubits}qubits:{data.get('status')}")returnfloat(data["time_taken"])defplot_results(qubits_list:list[int],timings:dict[str,list[float]],*,depth:int,shots:int,)->None:importmatplotlib.pyplotaspltfrommatplotlib.tickerimportMaxNLocator,ScalarFormatterplt.style.use("ggplot")fig,ax=plt.subplots(figsize=(9,5.5),dpi=150)fordevice,color,markerinBACKENDS:ax.plot(qubits_list,timings[device],label=device,color=color,marker=marker,markersize=7,linewidth=2,markerfacecolor="white",markeredgewidth=1.8,markeredgecolor=color,)ax.set_xlabel("Number of qubits",fontsize=12)ax.set_ylabel("Simulation time (s)",fontsize=12)ax.set_title(f"CPU vs GPU (QV depth={depth}, shots={shots})",fontsize=13,fontweight="semibold",pad=12,)ax.set_xticks(qubits_list)ax.xaxis.set_major_locator(MaxNLocator(integer=True))ax.yaxis.set_major_formatter(ScalarFormatter(useMathText=True))ax.set_yscale("log")ax.legend(frameon=True,fancybox=True,shadow=False,fontsize=10)ax.grid(True,which="both",linestyle="--",linewidth=0.6,alpha=0.7)fig.tight_layout()fig.savefig(OUTPUT,bbox_inches="tight")plt.close(fig)defmain()->None:parser=argparse.ArgumentParser(description="Compare CPU vs GPU on QV.")parser.add_argument("--qubits-min",type=int,default=20)parser.add_argument("--qubits-max",type=int,default=27)parser.add_argument("--depth",type=int,default=40)parser.add_argument("--shots",type=int,default=2000)args=parser.parse_args()qubits_list=list(range(args.qubits_min,args.qubits_max+1))timings:dict[str,list[float]]={device:[]fordevice,*_inBACKENDS}forqubitsinqubits_list:fordevice,*_inBACKENDS:elapsed=run_benchmark(qubits,device,depth=args.depth,shots=args.shots)timings[device].append(elapsed)print(f"qubits={qubits:2d}{device}:{elapsed:.6f}s",flush=True)fordevice,*_inBACKENDS:print(f"{device}:{timings[device]}",flush=True)plot_results(qubits_list,timings,depth=args.depth,shots=args.shots)print(f"Saved plot:{OUTPUT}",flush=True)if__name__=="__main__":main()

Submit the job to a GPU compute node withsbatch submit.sh. Usesqueue -u $USERto view the current user's jobs.

The result is shown below. GPU-based quantum circuit simulation is significantly faster.

CPU vs GPU performance comparison for the qiskit-aer simulator

Figure 11-1 CPU vs GPU performance comparison for the qiskit-aer simulator

The script above is located in/hpcfs/quantum/examples/qiskitfor reference (Qiskit 2.4.1, qiskit-aer 0.17.2).

PennyLane Simulator

An example Slurm job script (which can be namedsubmit.sh) is shown below:

#!/bin/bash#SBATCH --partition=gpu#SBATCH --qos=qcnormal#SBATCH --account=qc#SBATCH --job-name=qml-example#SBATCH --output=qml.%j.out#SBATCH --error=qml.%j.err#SBATCH --nodes=1#SBATCH --gres=gpu:v100:2#SBATCH --ntasks=8#SBATCH --mem=80Gmoduleuse/hpcfs/quantum/modulefilesmoduleloadquantum/pennylane-lightning-0.45.0echo"Python environment used:$(whichpython)"echo"Running on node:$SLURM_JOB_NODELIST"echo"Circuit: benchmark.py (25 qubits, 3 layers, 5 runs)"# CPU OpenMP uses 8 cores.OMP_NUM_THREADS=8pythonbenchmark.pylightning.qubit# cuQuantumGPU acceleration: one process uses a single GPU. mpirun -np 2 use two GPUs.pythonbenchmark.pylightning.gpumpirun-np2pythonbenchmark.pylightning.gpu# Kokkos GPU acceleration: one process uses a single GPU. mpirun -np 2 use two GPUs.pythonbenchmark.pylightning.kokkosmpirun-np2pythonbenchmark.pylightning.kokkos

benchmark.pybuilds a parameterized quantum circuit and computes its Jacobian, comparing the runtime of the following setups:

  • CPU: 8-core OpenMP parallelism (OMP_NUM_THREADS=8,lightning.qubitbackend)
  • GPU (cuQuantum):lightning.gpubackend, single GPU vs two GPUs (mpirun -np 2, MPI)
  • GPU (Kokkos):lightning.kokkosbackend, also single GPU vs two GPUs

The script is as follows:

"""Jacobian time for lightning.qubit, lightning.gpu, and lightning.kokkos.CPU, 8 OpenMP threads:OMP_NUM_THREADS=8 python benchmark.py lightning.qubitOne GPU (no MPI):python benchmark.py lightning.gpupython benchmark.py lightning.kokkosSeveral GPUs:mpirun -np 2 python benchmark.py lightning.gpumpirun -np 2 python benchmark.py lightning.kokkos"""importosimportsysfromtimeitimportdefault_timerastimerimportpennylaneasqmlwires=25layers=3num_runs=5DEVICES=("lightning.qubit","lightning.gpu","lightning.kokkos")defworld():rank=int(os.environ.get("OMPI_COMM_WORLD_RANK","0"))size=int(os.environ.get("OMPI_COMM_WORLD_SIZE","1"))returnrank,sizedefmain():iflen(sys.argv)!=2orsys.argv[1]notinDEVICES:names="|".join(DEVICES)print(f"usage: python benchmark.py{names}",file=sys.stderr)sys.exit(2)device_name=sys.argv[1]rank,size=world()# lightning.qubit is OpenMP only.ifdevice_name=="lightning.qubit":dev=qml.device(device_name,wires=wires,batch_obs=True)else:dev=qml.device(device_name,wires=wires,batch_obs=True,mpi=size>1)@qml.qnode(dev,diff_method="adjoint")defcircuit(parameters):qml.StronglyEntanglingLayers(weights=parameters,wires=range(wires))returnqml.math.hstack([qml.expval(qml.PauliZ(i))foriinrange(wires)])# Every MPI rank must differentiate the same parameters.qml.numpy.random.seed(0)shape=qml.StronglyEntanglingLayers.shape(n_layers=layers,n_wires=wires)weights=qml.numpy.random.random(size=shape)timing=[]for_inrange(num_runs):start=timer()qml.jacobian(circuit)(weights)timing.append(timer()-start)ifrank==0:ifdevice_name=="lightning.qubit":threads=os.environ.get("OMP_NUM_THREADS","default")where=f"{threads}threads"else:where=f"{size}GPU"print(f"{device_name:16}{where:10}{qml.numpy.mean(timing):.3f}s")if__name__=="__main__":main()

Typical output looks like this:

Circuit:benchmark.py(25qubits,3layers,5runs)lightning.qubit8threads240.511slightning.gpu1GPU10.512slightning.gpu2GPU33.425slightning.kokkos1GPU19.543slightning.kokkos2GPU12.690s

Compared with the CPU (8-core OpenMP), single-GPU speedups are substantial: about 23× forlightning.gpuand about 12× forlightning.kokkos. The backends differ in their underlying implementations:lightning.gpuis built on NVIDIA cuQuantum (cuStateVec) and is heavily optimized for CUDA GPUs, so it is usually faster on a single card;lightning.kokkosis based on the portable Kokkos parallel framework, runs on a wider range of hardware, and often scales more steadily across multiple GPUs (MPI). In this example, two GPUs further speed uplightning.kokkosrelative to one GPU, whilelightning.gpubecomes slower—communication overhead outweighs the parallel benefit. Small circuits are not always a good fit for multi-GPU runs; you should benchmark to find the best setup for your workload.

The script above is located in/hpcfs/quantum/examples/pennylanefor reference (PennyLane 0.45.0, cuStateVec 1.9.0).

FAQ

SeeFAQ.

AI 助手
快速提问 ×

有问题?输入后跳转到对话页继续交流

Baidu
map