def test_simulated_backend_descriptive_name():
p = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow')
assert str(p) == 'rainbow-simulator'
assert isinstance(p.get_sampler(), cirq.Simulator)
p = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow',
noise_strength=1e-3)
assert str(p) == 'rainbow-depol(1.000e-03)'
assert isinstance(p.get_sampler(), cirq.DensityMatrixSimulator)
p = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow',
noise_strength=float('inf'))
assert str(p) == 'rainbow-zeros'
assert isinstance(p.get_sampler(), cirq.ZerosSampler)
def test_quantum_runtime_configuration_serialization(tmpdir):
rt_config = cg.QuantumRuntimeConfiguration(
processor_record=cg.SimulatedProcessorWithLocalDeviceRecord('rainbow'),
run_id='unit-test',
)
cg_assert_equivalent_repr(rt_config)
_assert_json_roundtrip(rt_config, tmpdir)
def test_execute(tmpdir, run_id_in):
rt_config = cg.QuantumRuntimeConfiguration(
processor_record=cg.SimulatedProcessorWithLocalDeviceRecord('rainbow'),
run_id=run_id_in,
qubit_placer=cg.NaiveQubitPlacer(),
)
executable_group = cg.QuantumExecutableGroup(_get_quantum_executables())
returned_exegroup_result = cg.execute(rt_config=rt_config,
executable_group=executable_group,
base_data_dir=tmpdir)
run_id = returned_exegroup_result.shared_runtime_info.run_id
if run_id_in is not None:
assert run_id_in == run_id
else:
assert isinstance(uuid.UUID(run_id), uuid.UUID)
manual_exegroup_result = _load_result_by_hand(tmpdir, run_id)
egr_record: cg.ExecutableGroupResultFilesystemRecord = cirq.read_json_gzip(
f'{tmpdir}/{run_id}/ExecutableGroupResultFilesystemRecord.json.gz')
exegroup_result: cg.ExecutableGroupResult = egr_record.load(
base_data_dir=tmpdir)
helper_loaded_result = cg.ExecutableGroupResultFilesystemRecord.from_json(
run_id=run_id, base_data_dir=tmpdir).load(base_data_dir=tmpdir)
# TODO(gh-4699): Don't null-out device once it's serializable.
assert isinstance(returned_exegroup_result.shared_runtime_info.device,
cirq.Device)
returned_exegroup_result.shared_runtime_info.device = None
assert returned_exegroup_result == exegroup_result
assert manual_exegroup_result == exegroup_result
assert helper_loaded_result == exegroup_result
def rt_config(request):
if request.param == 'minimal':
return cg.QuantumRuntimeConfiguration(
processor_record=cg.SimulatedProcessorWithLocalDeviceRecord('rainbow')
)
elif request.param == 'full':
return cg.QuantumRuntimeConfiguration(
processor_record=cg.SimulatedProcessorWithLocalDeviceRecord('rainbow'),
run_id='unit-test',
random_seed=52,
qubit_placer=cg.RandomDevicePlacer(),
target_gateset=cirq.CZTargetGateset(),
)
raise ValueError(f"Unknown flavor {request}") # coverage: ignore
def test_simulated_backend_with_local_device():
proc_rec = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow')
assert isinstance(proc_rec.get_processor(), cg.engine.AbstractProcessor)
assert proc_rec.processor_id == 'rainbow'
assert str(proc_rec) == 'rainbow-simulator'
cirq.testing.assert_equivalent_repr(proc_rec,
global_vals={'cirq_google': cg})
def test_engine_result():
proc_rec = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow')
proc = proc_rec.get_processor()
samp = proc_rec.get_sampler()
circ = cirq.Circuit(cirq.measure(cirq.GridQubit(5, 4)))
res1 = proc.run(circ)
assert isinstance(res1, cg.EngineResult)
res2 = samp.run(circ)
assert isinstance(res2, cg.EngineResult)
def test_quantum_runtime_configuration():
rt_config = cg.QuantumRuntimeConfiguration(
processor_record=cg.SimulatedProcessorWithLocalDeviceRecord('rainbow'),
run_id='unit-test',
)
sampler = rt_config.processor_record.get_sampler()
result = sampler.run(
cirq.Circuit(cirq.measure(cirq.GridQubit(5, 3), key='z')))
assert isinstance(result, cirq.Result)
assert isinstance(rt_config.processor_record.get_device(), cirq.Device)
def test_simulated_backend_descriptive_name():
p = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow')
assert str(p) == 'rainbow-simulator'
assert isinstance(p.get_sampler(), cg.engine.ProcessorSampler)
# The actual simulator hiding behind the indirection is
# p.get_sampler() -> ProcessorSampler
# p.get_sampler().processor._sampler -> Validating Sampler
# p.get_sampler().processor._sampler._sampler -> The actual simulator
assert isinstance(p.get_sampler().processor._sampler._sampler,
cirq.Simulator)
p = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow',
noise_strength=1e-3)
assert str(p) == 'rainbow-depol(1.000e-03)'
assert isinstance(p.get_sampler().processor._sampler._sampler,
cirq.DensityMatrixSimulator)
p = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow',
noise_strength=float('inf'))
assert str(p) == 'rainbow-zeros'
assert isinstance(p.get_sampler().processor._sampler._sampler,
cirq.ZerosSampler)
def test_hardcoded_qubit_placer():
rainbow_record = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow')
rainbow_device = rainbow_record.get_device()
rainbow_graph = rainbow_device.metadata.nx_graph
hardcoded = cg.HardcodedQubitPlacer(_all_offset_placements(rainbow_graph))
topo = cirq.TiltedSquareLattice(3, 2)
circuit = cirq.experiments.random_rotations_between_grid_interaction_layers_circuit(
qubits=sorted(topo.nodes_as_gridqubits()), depth=4)
shared_rt_info = cg.SharedRuntimeInfo(run_id='example',
device=rainbow_device)
rs = np.random.RandomState(10)
placed_c, placement = hardcoded.place_circuit(
circuit, problem_topology=topo, shared_rt_info=shared_rt_info, rs=rs)
cirq.is_valid_placement(rainbow_graph, topo.graph, placement)
assert isinstance(placed_c, cirq.FrozenCircuit)
def test_executable_group_result(tmpdir):
egr = cg.ExecutableGroupResult(
runtime_configuration=cg.QuantumRuntimeConfiguration(
processor_record=cg.SimulatedProcessorWithLocalDeviceRecord(
'rainbow'),
run_id='unit-test',
),
shared_runtime_info=cg.SharedRuntimeInfo(run_id='my run'),
executable_results=[
cg.ExecutableResult(
spec=_get_example_spec(name=f'test-spec-{i}'),
runtime_info=cg.RuntimeInfo(execution_index=i),
raw_data=cirq.ResultDict(
params=cirq.ParamResolver(),
measurements={'z': np.ones((1_000, 4))}),
) for i in range(3)
],
)
def test_filesystem_saver(tmpdir):
run_id = 'asdf'
fs_saver = _FilesystemSaver(base_data_dir=tmpdir, run_id=run_id)
rt_config = cg.QuantumRuntimeConfiguration(
processor_record=cg.SimulatedProcessorWithLocalDeviceRecord('rainbow'), run_id=run_id
)
shared_rt_info = cg.SharedRuntimeInfo(run_id=run_id)
fs_saver.initialize(rt_config, shared_rt_info=shared_rt_info)
# Test 1: assert fs_saver.initialize() has worked.
rt_config2 = cirq.read_json_gzip(f'{tmpdir}/{run_id}/QuantumRuntimeConfiguration.json.gz')
shared_rt_info2 = cirq.read_json_gzip(f'{tmpdir}/{run_id}/SharedRuntimeInfo.json.gz')
assert rt_config == rt_config2
assert shared_rt_info == shared_rt_info2
# Test 2: assert `consume_result()` works.
# you shouldn't actually mutate run_id in the shared runtime info, but we want to test
# updating the shared rt info object:
shared_rt_info.run_id = 'updated_run_id'
exe_result = cg.ExecutableResult(
spec=None,
runtime_info=cg.RuntimeInfo(execution_index=0),
raw_data=cirq.ResultDict(
params=cirq.ParamResolver({}), measurements={'z': np.ones((100, 5))}
),
)
fs_saver.consume_result(exe_result=exe_result, shared_rt_info=shared_rt_info)
shared_rt_info3 = cirq.read_json_gzip(f'{tmpdir}/{run_id}/SharedRuntimeInfo.json.gz')
exe_result3 = cirq.read_json_gzip(f'{tmpdir}/{run_id}/ExecutableResult.0.json.gz')
assert shared_rt_info == shared_rt_info3
assert exe_result == exe_result3
# Test 3: assert loading egr_record works.
egr_record: cg.ExecutableGroupResultFilesystemRecord = cirq.read_json_gzip(
f'{fs_saver.data_dir}/ExecutableGroupResultFilesystemRecord.json.gz'
)
assert egr_record == fs_saver.egr_record
exegroup_result: cg.ExecutableGroupResult = egr_record.load(base_data_dir=tmpdir)
assert exegroup_result.shared_runtime_info == shared_rt_info
assert exegroup_result.runtime_configuration == rt_config
assert exegroup_result.executable_results[0] == exe_result
def test_sampler_equality():
p = cg.SimulatedProcessorWithLocalDeviceRecord('rainbow')
assert p.get_sampler().__class__ == p.get_processor().get_sampler(
).__class__
def test_simulated_backend_with_bad_local_device():
proc_rec = cg.SimulatedProcessorWithLocalDeviceRecord('my_processor')
with pytest.raises(KeyError):
proc_rec.get_device()
