def test_run_remote_simulator_compile(self):
qjob = jobp.QuantumJob(self.qc,
doCompile=True,
backend='ibmqx_qasm_simulator')
api = IBMQuantumExperience(self.QE_TOKEN, {"url": self.QE_URL},
verify=True)
jobp.run_remote_backend(qjob.qobj, api)
def test_compile_job(self):
"""Test compilation as part of job"""
qjob = jobp.QuantumJob(self.qasm_text,
doCompile=True,
backend='local_qasm_simulator')
jp = jobp.JobProcessor([qjob], callback=None)
jp.submit(silent=True)
def test_run_local_simulator_unitary(self):
compiled_circuit = openquantumcompiler.compile(self.qc.qasm())
quantum_job = jobprocessor.QuantumJob(
compiled_circuit,
doCompile=False,
backend='local_unitary_simulator')
jobprocessor.run_local_simulator(quantum_job.qobj)
def test_init_job_processor(self):
njobs = 5
job_list = []
for i in range(njobs):
qjob = jobp.QuantumJob(self.qc, doCompile=False)
job_list.append(qjob)
jp = jobp.JobProcessor(job_list, callback=None)
def test_run_job_processor_local_parallel(self):
def job_done_callback(results):
try:
self.log.info(pprint.pformat(results))
for result in results:
self.assertTrue(result.get_status() == 'COMPLETED')
except Exception as e:
self.job_processor_exception = e
finally:
self.job_processor_finished = True
njobs = 20
job_list = []
for i in range(njobs):
compiled_circuit = openquantumcompiler.compile(self.qc.qasm())
quantum_job = jobprocessor.QuantumJob(
compiled_circuit, backend='local_qasm_simulator')
job_list.append(quantum_job)
self.job_processor_finished = False
self.job_processor_exception = None
jp = jobprocessor.JobProcessor(job_list,
max_workers=None,
callback=job_done_callback)
jp.submit(silent=True)
while not self.job_processor_finished:
# Wait until the job_done_callback is invoked and completed.
pass
if self.job_processor_exception:
raise self.job_processor_exception
def test_mix_local_remote_jobs(self):
"""test mixing local and remote jobs
Internally local jobs execute in seperate processes since
they are CPU bound and remote jobs execute in seperate threads
since they are I/O bound. The module gets results from potentially
both kinds in one list. Test that this works.
"""
njobs = 6
job_list = []
basis = 'u1,u2,u3,cx'
backend_type = ['local_qasm_simulator', 'ibmqx_qasm_simulator']
i = 0
for circuit in self.rqg.get_circuits(format='QuantumCircuit')[:njobs]:
compiled_circuit = openquantumcompiler.compile(circuit.qasm())
backend = backend_type[i % len(backend_type)]
self.log.info(backend)
qjob = jobp.QuantumJob(compiled_circuit, backend=backend)
job_list.append(qjob)
i += 1
jp = jobp.JobProcessor(job_list,
max_workers=None,
token=self.QE_TOKEN,
url=self.QE_URL,
callback=None)
jp.submit(silent=True)
def test_run_remote_simulator(self):
compiled_circuit = openquantumcompiler.compile(self.qc.qasm())
qjob = jobp.QuantumJob(compiled_circuit,
doCompile=False,
backend='ibmqx_qasm_simulator')
api = IBMQuantumExperience(self.QE_TOKEN, {"url": self.QE_URL},
verify=True)
jobp.run_remote_backend(qjob.qobj, api)
def test_backend_not_found(self):
compiled_circuit = openquantumcompiler.compile(self.qc.qasm())
job = jobprocessor.QuantumJob(compiled_circuit,
backend='non_existing_backend')
self.assertRaises(QISKitError,
jobprocessor.JobProcessor, [job],
callback=None,
token=self.QE_TOKEN,
url=self.QE_URL)
def test_run_job_processor_local(self):
njobs = 5
job_list = []
for i in range(njobs):
compiled_circuit = openquantumcompiler.compile(self.qc.qasm())
qjob = jobp.QuantumJob(compiled_circuit,
backend='local_qasm_simulator',
doCompile=False)
job_list.append(qjob)
jp = jobp.JobProcessor(job_list, callback=None)
jp.submit(silent=True)
def test_random_local(self):
"""test randomly generated circuits on local_qasm_simulator"""
njobs = 5
job_list = []
basis = 'u1,u2,u3,cx,id'
backend = 'local_qasm_simulator'
for circuit in self.rqg.get_circuits(format='QuantumCircuit')[:njobs]:
compiled_circuit = openquantumcompiler.compile(circuit.qasm())
qjob = jobp.QuantumJob(compiled_circuit, backend=backend)
job_list.append(qjob)
jp = jobp.JobProcessor(job_list, max_workers=1, callback=None)
jp.submit(silent=True)
def test_run_job_processor_online(self):
njobs = 1
job_list = []
for i in range(njobs):
compiled_circuit = openquantumcompiler.compile(self.qc.qasm())
qjob = jobp.QuantumJob(compiled_circuit,
backend='ibmqx_qasm_simulator')
job_list.append(qjob)
jp = jobp.JobProcessor(job_list,
token=self.QE_TOKEN,
url=self.QE_URL,
callback=None)
jp.submit(silent=True)
def test_run_job_processor_local_parallel(self):
njobs = 20
job_list = []
for i in range(njobs):
compiled_circuit = openquantumcompiler.compile(self.qc.qasm())
qjob = jobp.QuantumJob(compiled_circuit,
backend='local_qasm_simulator')
job_list.append(qjob)
def job_done_callback(results):
self.log.info(pprint.pformat(results))
for result, _ in results:
self.assertTrue(result['result'][0]['status'] == 'DONE')
jp = jobp.JobProcessor(job_list,
max_workers=None,
callback=job_done_callback)
jp.submit(silent=True)
def test_init_quantum_job_qobj(self):
formatted_circuit = self.qasm_text
qobj = {
'id':
'qobj_init',
'config': {
'max_credits': 3,
'shots': 1024,
'backend': 'local_qasm_simulator'
},
'circuits': [{
'name': 'example',
'compiled_circuit': formatted_circuit,
'layout': None,
'seed': None
}]
}
qjob = jobp.QuantumJob(qobj, preformatted=True)
def test_error_in_job(self):
njobs = 5
job_list = []
for i in range(njobs):
compiled_circuit = openquantumcompiler.compile(self.qc.qasm())
qjob = jobp.QuantumJob(compiled_circuit,
backend='local_qasm_simulator')
job_list.append(qjob)
def job_done_callback(results):
for result, _ in results:
self.log.info(pprint.pformat(result))
self.assertTrue(result['status'] == 'ERROR')
jp = jobp.JobProcessor(job_list,
max_workers=None,
callback=job_done_callback)
tmp = jobp.run_local_simulator
jobp.run_local_simulator = mock_run_local_simulator
jp.submit(silent=True)
jobp.run_local_simulator = tmp
def test_init_quantum_job(self):
quantum_job = jobprocessor.QuantumJob(self.qc)
def test_run_local_simulator_compile(self):
quantum_job = jobprocessor.QuantumJob(self.qasm_text,
doCompile=True,
backend='local_qasm_simulator')
jobprocessor.run_local_simulator(quantum_job.qobj)
def testrun_local_simulator(self):
compiled_circuit = openquantumcompiler.compile(self.qc.qasm())
qjob = jobp.QuantumJob(compiled_circuit,
doCompile=False,
backend='local_qasm_simulator')
jobp.run_local_simulator(qjob.qobj)
def test_init_quantum_job(self):
qjob = jobp.QuantumJob(self.qc)
def testrun_local_simulator_compile(self):
qjob = jobp.QuantumJob(self.qasm_text,
doCompile=True,
backend='local_qasm_simulator')
jobp.run_local_simulator(qjob.qobj)
