Minimal demo added. README updated to mention demo.

README.md

@@ -23,6 +23,9 @@ The repository contains the following:
 - plots_display_all.ipynb: the notebook used to display plots of benchmarks (mainly extracting the data from 'data' folder as above and integrating them into the files in 'plot_scripts')
 - expectation_plots.ipynb: the notebook used to display plots corresponding to expectation values (mainly extracting the data from 'exp_data' folder and integrating them into the plot files)
 
+
+The `demo` folder has further instructions that reproduces a minimal example of files required to execute the toolchain on a HPC cluster while collecting the profiling data.
+
 # Zenodo repository
 
 The container images used to generate the benchmarks and their usage are shared at the Zenodo repository: https://zenodo.org/records/10376217

demo/README.md

@@ -0,0 +1,85 @@
+This is a demo of the toolchain. The qalgo folder has the quantum algorithm to be benchmarked with folders:
+
+- gen_files: This folder has the main machinery that generates the associated run files given the qasm files, job scripts and scope files that scope into environment of the container
+- qasm_files: The quantum algorithm represented using the QASM instruction set
+- qasm_parser: The parser that translates the QASM instruction into the instruction of the simulation package
+- simulation package folder: The folder of the simulation package with the associated run files and job scripts
+
+To generate the associated files, in this instance the qiskit files associated with the Heisenberg dynamics:
+
+1. Create qiskit folder in qalgo folder
+
+- mkdir -v qiskit
+
+2. Change into the gen_files folder and run the file
+
+- python3 create_dir_struct.py (allows to set the options inside the file)
+
+3. In the qiskit folder the following folders are generated:
+
+- bash_scripts_st_dp: bash scripts that scope the run files into the environment of the container
+- data_st_dp: data folder to store the time statistics
+- error_st_dp: error folder to store the errors of the job
+- output_st_dp: output folder to store the output of the job
+- job_scripts_st_dp: job scripts folder that has the jobs to be executed on the cluster (tailored for PSI cluster)
+- run_files_st_dp: translated run files from qasm to qiskit instruction set
+
+4. run_jobs_st_dp.sh: pushes all the jobs in the `bash_scripts_st_dp` onto the cluster
+
+=============================================================================================================================
+
+Note: 
+
+1. The above instructions are tailored for a demo i.e., a minimal reproduction of the toolchain and its files (for
+   the entire version: please see the files in the folder `toolchain`)
+
+2. 1. The singularity containers are not contained in this repo but are on the zenodo repo. These can be accessed using
+   the following commands or as in the job scripts:
+
+   - singularity shell qucos_sim.sif
+
+3. The containerized image has conda environments for all the packages (also in `bash_script_sample.sh` in zenodo repo) that is
+   as follows:
+
+```
+   #!/bin/bash -l
+   . /app/etc/profile.d/conda.sh
+   conda activate sim_package
+   python3 /home/<translated_run_file.py>
+
+   # Available conda environments on CPU singularity image: qucos_sim.sif
+   # Can be activated by issuing the commands as above, replace sim_package
+   # by the package of choice as below:
+   # sim_braket
+   # sim_cirq
+   # sim_hybridq
+   # sim_myqlm
+   # sim_myqlm_cpp
+   # sim_pennylane
+   # sim_pennylane_l
+   # sim_projectq
+   # sim_qibo
+   # sim_qibojit
+   # sim_qiskit
+   # sim_qpanda
+   # sim_qsimcirq
+   # sim_qulacs
+   # sim_svsim
+
+   # Available conda environments on GPU singularity image: qucos_gpu_sim.sif
+   # Can be activated by issuing the commands as above, replace sim_package
+   # by the package of choice as below:
+   # sim_hybridq_gpu
+   # sim_pennylane_l_gpu
+   # sim_qcgpu_gpu
+   # sim_qibojit_gpu
+   # sim_qiskit_gpu
+   # sim_qpanda_gpu
+   # sim_qsimcirq_gpu
+   # sim_qulacs_gpu
+   # sim_svsim_gpu
+```
+
+4. The use of containerized image implies that the packages installed in the container do not need additional dependencies
+   and can be used in a straight out-of-box fashion. However to check the dependencies one can issue the command 
+   `pip list` once the corresponding conda environment is activated (conda environments listed above).  

demo/qalgo/gen_files/create_bash_script.py

@@ -0,0 +1,23 @@
+import sys 
+import os
+import subprocess
+
+sim_pack = sys.argv[1]
+task = sys.argv[2]
+com_cap = sys.argv[3]
+prec = sys.argv[4]
+
+N_arr = range(6, 36, 2)
+
+for N in N_arr:
+    with open('{}_{}_{}_{}.sh'.format(task, com_cap, prec, N), 'a') as job_file:
+        job_file.write('#!/bin/bash -l\n')
+        job_file.write('. /app/etc/profile.d/conda.sh\n')
+
+        if com_cap == 'st' or com_cap == 'mt':
+            job_file.write('conda activate sim_{}\n'.format(sim_pack))
+
+        elif com_cap == 'gpu':
+            job_file.write('conda activate sim_{}_gpu\n'.format(sim_pack))
+
+        job_file.write('python3 /home/{}_n{}.py\n'.format(task, N))

demo/qalgo/gen_files/create_dir_struct.py

@@ -0,0 +1,73 @@
+import os
+
+sim_pack = 'qiskit'
+task = 'hdyn'
+com_cap = 'st'
+prec = 'dp'
+
+gen_path = os.path.abspath(os.getcwd()) + '/'
+# print(gen_path)
+par_dir_path = os.path.abspath(os.path.join(gen_path, os.pardir))
+# print(par_dir_path)
+sim_path = par_dir_path + '/{}/'.format(sim_pack)
+
+# print(sim_path)
+
+print(' ############################ ')
+
+print('### Create job scripts folder for package: {}, task: {},  compute cap: {}, precision: {}'.format(sim_pack, task, com_cap, prec))
+job_scripts_path = sim_path+'job_scripts_{}_{}'.format(com_cap, prec)
+print(job_scripts_path)
+os.mkdir(job_scripts_path)
+
+print('### Create job scripts')
+os.chdir(job_scripts_path)
+cjs = gen_path+'create_job_script.py {} {} {} {}'.format(sim_pack, task, com_cap, prec)
+os.system('python3 {}'.format(cjs))
+
+print(' ############################ ')
+
+print('### Create bash scripts folder for package: {}, task: {},  compute cap: {}, precision: {}'.format(sim_pack, task, com_cap, prec))
+bash_scripts_path = sim_path+'bash_scripts_{}_{}'.format(com_cap, prec)
+os.mkdir(bash_scripts_path)
+
+print('### Create bash scripts')
+os.chdir(bash_scripts_path)
+cbs = gen_path+'create_bash_script.py {} {} {} {}'.format(sim_pack, task, com_cap, prec)
+os.system('python3 {}'.format(cbs))
+
+print(' ############################ ')
+
+print('### Create output folder')
+os.mkdir(sim_path+'output_{}_{}'.format(com_cap, prec))
+
+print('### Create error folder')
+os.mkdir(sim_path+'error_{}_{}'.format(com_cap, prec))
+
+print('### Create data folder')
+os.mkdir(sim_path+'data_{}_{}'.format(com_cap, prec))
+
+print(' ############################ ')
+
+print('### Create run files folder package: {}, task: {},  compute cap: {}, precision: {}'.format(sim_pack, task, com_cap, prec))
+run_files_path = sim_path+'run_files_{}_{}'.format(com_cap, prec)
+os.mkdir(run_files_path)
+
+# sim_parser = input("Enter the python file including the path for the parser: ")
+sim_parser = par_dir_path + '/qasm_parser/qasm_qiskit_parser_2pt0_new.py'
+os.system('python3 {}'.format(sim_parser))
+
+print(' ############################ ')
+
+print('### Create bash scripts to run jobs')
+os.chdir(sim_path)
+
+with open('run_jobs_{}_{}.sh'.format(com_cap, prec), 'w') as f:
+
+    f.write('path={}job_scripts_{}_{}\n'.format(sim_path, com_cap, prec))
+    f.write('cd $path\n')
+    f.write('for job_script in *.sh; do\n')
+    f.write('echo $job_script;\n')
+    f.write('sbatch $job_script;\n')
+    f.write('done\n')
+

demo/qalgo/gen_files/create_job_script.py

@@ -0,0 +1,83 @@
+import numpy as np
+import sys
+import os
+
+N_arr = np.arange(6, 36, 2)
+# N_arr = np.append(N_arr, np.arange(41, 51, 1))
+# _partition = 'hourly'
+
+# sim_pack = 'qiskit'
+# task = 'hdyn'
+# com_cap = 'st'
+# prec = 'dp'
+
+sim_pack = sys.argv[1]
+task = sys.argv[2]
+com_cap = sys.argv[3]
+prec = sys.argv[4]
+
+gen_path = os.path.abspath(os.getcwd()) + '/'
+par_dir_path = os.path.abspath(os.path.join(gen_path, os.pardir)) + '/'
+sim_path = par_dir_path + '/{}/'.format(sim_pack)
+
+for ind, N in enumerate(N_arr):
+    with open('{}_{}_{}_{}.sh'.format(task, com_cap, prec, N), 'a') as job_file:
+            job_file.write('#!/bin/bash -l\n')
+            job_file.write('#SBATCH --job-name={}_{}_{}_{}_{}\n'.format(sim_pack, task, com_cap, prec, N))
+
+            if N < 26:
+                job_file.write('#SBATCH --partition=hourly\n')
+            else:
+                job_file.write('#SBATCH --partition=general\n')
+
+            if com_cap == 'st':
+                job_file.write('#SBATCH --hint=nomultithread\n')
+                job_file.write('#SBATCH --nodes=1\n')
+                job_file.write('#SBATCH --ntasks=1\n')
+                job_file.write('#SBATCH --cpus-per-task=1\n')
+                job_file.write('#SBATCH --ntasks-per-core=1\n')
+
+            elif com_cap == 'mt':
+                job_file.write('#SBATCH --hint=multithread\n')
+                job_file.write('#SBATCH --nodes=1\n')
+                job_file.write('#SBATCH --ntasks=1\n')
+                job_file.write('#SBATCH --cpus-per-task=42\n')
+                job_file.write('#SBATCH --ntasks-per-core=2\n')
+
+            if N < 26:
+                job_file.write('#SBATCH --mem=30G\n')
+            else:
+                job_file.write('#SBATCH --mem=300G\n')
+            if N < 26:
+                job_file.write('#SBATCH --time=01:00:00\n')
+            else:
+                job_file.write('#SBATCH --time=23:00:00\n')
+
+            # job_file.write('#SBATCH --mail-user=amit.gangapuram@psi.ch\n')
+            # job_file.write('#SBATCH --mail-type=BEGIN,END,FAIL\n')
+            # job_file.write('#SBATCH --output /data/user/gangap_a/{}_singular/{}/output_{}_{}/{}_{}_{}_{}.out\n'.format(task, sim_pack, com_cap, prec, task, com_cap, prec, N))
+            # job_file.write('#SBATCH --error /data/user/gangap_a/{}_singular/{}/error_{}_{}/{}_{}_{}_{}.err\n'.format(task, sim_pack, com_cap, prec, task, com_cap, prec, N))
+            job_file.write('\n\n')
+
+            if sim_pack == 'projectq' or sim_pack == 'quest' or sim_pack == 'intel_qs_cpp' or sim_pack == 'svsim' or sim_pack == 'hybridq' or sim_pack == 'hiq' or sim_pack == 'qibo' or sim_pack == 'qibojit' or sim_pack == 'qrack_sch' or sim_pack == 'qrack_opt' or sim_pack == 'pennylane_l' or sim_pack == 'qpp' or sim_pack == 'qpanda' or sim_pack =='braket' or sim_pack == 'myqlm' or sim_pack == 'myqlm_cpp':
+                if com_cap == 'st':
+                    job_file.write('OMP_NUM_THREADS=1\n')
+                    job_file.write('export OMP_NUM_THREADS\n')
+
+                elif com_cap == 'mt':
+                    job_file.write('OMP_NUM_THREADS=84\n')
+                    job_file.write('export OMP_NUM_THREADS\n')
+
+                job_file.write('export SRUN_CPUS_PER_TASK=$SLURM_CPUS_PER_TASK\n')
+
+
+            else:
+                job_file.write('export APPTAINER_BIND="{}bash_scripts_{}_{}/:/brf,{}run_files_{}_{}/:/home,{}data_{}_{}/\"\n'.format(par_dir_path, com_cap, prec, par_dir_path, com_cap, prec, par_dir_path, com_cap, prec))
+
+                if com_cap == 'gpu':
+                    job_file.write('singularity exec --nv /data/user/gangap_a/singularity_images/qucos_gpu_sim.sif bash /brf/{}_{}_{}_{}.sh\n'.format(task, com_cap, prec, N))
+                else:
+                    job_file.write('singularity exec <path_to_singularity_image>/qucos_sim.sif bash /brf/{}_{}_{}_{}.sh\n'.format(task, com_cap, prec, N))
+
+
+

demo/qalgo/gen_files/run_jobs_st_dp.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+task='hdyn'
+sim_pack='qiskit'
+com_cap='st'
+prec='dp'
+
+cd ..
+cd ${sim_pack}
+
+for job_script in *.sh; do
+echo $job_script;
+sbatch $job_script;
+done
+

demo/qalgo/qasm_parser/qasm_qiskit_parser_2pt0_new.py

@@ -0,0 +1,168 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+import os
+
+def parse_qasm_to_package_gen(N, mpt, spt, f_precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from qiskit import QuantumRegister, QuantumCircuit, transpile, ClassicalRegister\n')
+        f.write('from qiskit.quantum_info.operators import Operator\n')
+        f.write('from qiskit.providers.aer import QasmSimulator\n')
+        f.write('from qiskit import Aer\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('backend = Aer.get_backend(\'statevector_simulator\')#, max_parallel_threads={}, statevector_parallel_threshold={}, precision=\'{}\')\n'.format(mpt, spt, f_precision))
+        f.write('opt = backend.options\n')
+        f.write('opt.max_parallel_threads={}\n'.format(mpt))
+        f.write('opt.statevector_parallel_threshold={}\n'.format(spt))
+        f.write('opt.precision=\'{}\'\n'.format(f_precision))
+
+        f.write('cir = QuantumCircuit({})\n'.format(N))
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}({})\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}(np.pi*{}, {})\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.cx({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi/2., np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi*{}, np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('job = backend.run(transpile(cir, backend))\n')
+        f.write('result = job.result()\n')
+        f.write('outputstate = result.get_statevector(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+        # f.write('print(t_e - t_s)\n')
+        # f.write('print(t_ep - t_sp)\n')
+
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+task = 'hdyn'
+sim_pack = 'qiskit'
+com_cap = 'st'
+prec = 'dp'
+
+gen_path = os.path.abspath(os.getcwd())
+print(gen_path)
+par_dir_path = os.path.abspath(os.path.join(gen_path, os.pardir))
+print(par_dir_path)
+par2_dir_path = os.path.abspath(os.path.join(par_dir_path, os.pardir))
+print(par2_dir_path)
+
+
+for N in range(6, 38, 2):
+    input_file_path = par2_dir_path + '/qasm_files/'
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = par2_dir_path + '/{}/data_{}_{}'.format(sim_pack, com_cap, prec)
+
+    output_file_path = par2_dir_path + '/{}/run_files_{}_{}/'.format(sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 1, 40, "double", input_file, output_file, save_file_path)