def test_random_device_placer_bad_device():
topo = cirq.LineTopology(8)
qubits = cirq.LineQubit.range(8)
circuit = cirq.testing.random_circuit(qubits, n_moments=8, op_density=1.0, random_state=52)
qp = cg.RandomDevicePlacer()
with pytest.raises(ValueError, match=r'.*shared_rt_info\.device.*'):
qp.place_circuit(
circuit,
problem_topology=topo,
shared_rt_info=cg.SharedRuntimeInfo(run_id='1'),
rs=np.random.RandomState(1),
)
def test_quantum_runtime_configuration_qubit_placer(rt_config):
device = rt_config.processor_record.get_device()
c, _ = rt_config.qubit_placer.place_circuit(
cirq.Circuit(cirq.measure(cirq.LineQubit(0), cirq.LineQubit(1), key='z')),
problem_topology=cirq.LineTopology(n_nodes=2),
shared_rt_info=cg.SharedRuntimeInfo(run_id=rt_config.run_id, device=device),
rs=np.random.RandomState(rt_config.random_seed),
)
if isinstance(rt_config.qubit_placer, cg.NaiveQubitPlacer):
assert all(isinstance(q, cirq.LineQubit) for q in c.all_qubits())
else:
assert all(isinstance(q, cirq.GridQubit) for q in c.all_qubits())
def test_random_device_placer_small_device():
topo = cirq.TiltedSquareLattice(3, 3)
qubits = sorted(topo.nodes_to_gridqubits().values())
circuit = cirq.experiments.random_rotations_between_grid_interaction_layers_circuit(
qubits, depth=8, two_qubit_op_factory=lambda a, b, _: cirq.SQRT_ISWAP(a, b)
)
qp = cg.RandomDevicePlacer()
with pytest.raises(cg.CouldNotPlaceError):
qp.place_circuit(
circuit,
problem_topology=topo,
shared_rt_info=cg.SharedRuntimeInfo(run_id='1', device=cg.Foxtail),
rs=np.random.RandomState(1),
)
def test_executable_group_result(tmpdir):
egr = cg.ExecutableGroupResult(
runtime_configuration=cg.QuantumRuntimeConfiguration(
processor=_MockEngineProcessor(),
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.Result(params=cirq.ParamResolver(),
measurements={'z': np.ones((1_000, 4))}),
) for i in range(3)
],
)
def test_filesystem_saver(tmpdir, patch_cirq_default_resolvers):
assert patch_cirq_default_resolvers
run_id = 'asdf'
fs_saver = _FilesystemSaver(base_data_dir=tmpdir, run_id=run_id)
rt_config = cg.QuantumRuntimeConfiguration(
processor=_MockEngineProcessor(), 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.Result(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_random_device_placer_line():
topo = cirq.LineTopology(8)
qubits = cirq.LineQubit.range(8)
circuit = cirq.testing.random_circuit(qubits, n_moments=8, op_density=1.0, random_state=52)
qp = cg.RandomDevicePlacer()
circuit2, mapping = qp.place_circuit(
circuit,
problem_topology=topo,
shared_rt_info=cg.SharedRuntimeInfo(run_id='1', device=cg.Sycamore23),
rs=np.random.RandomState(1),
)
assert circuit is not circuit2
assert circuit != circuit2
assert all(q in cg.Sycamore23.qubit_set() for q in circuit2.all_qubits())
for k, v in mapping.items():
assert k != v
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_device_missing_metadata():
class BadDevice(cirq.Device):
pass
topo = cirq.TiltedSquareLattice(3, 3)
qubits = sorted(topo.nodes_to_gridqubits().values())
circuit = cirq.experiments.random_rotations_between_grid_interaction_layers_circuit(
qubits,
depth=8,
two_qubit_op_factory=lambda a, b, _: cirq.SQRT_ISWAP(a, b))
qp = cg.RandomDevicePlacer()
with pytest.raises(ValueError):
qp.place_circuit(
circuit,
problem_topology=topo,
shared_rt_info=cg.SharedRuntimeInfo(run_id='1',
device=BadDevice()),
rs=np.random.RandomState(1),
)
def test_random_device_placer_tilted_square_lattice():
topo = cirq.TiltedSquareLattice(4, 2)
qubits = sorted(topo.nodes_to_gridqubits().values())
circuit = cirq.experiments.random_rotations_between_grid_interaction_layers_circuit(
qubits, depth=8, two_qubit_op_factory=lambda a, b, _: cirq.SQRT_ISWAP(a, b)
)
assert not all(q in cg.Sycamore23.qubit_set() for q in circuit.all_qubits())
qp = cg.RandomDevicePlacer()
circuit2, mapping = qp.place_circuit(
circuit,
problem_topology=topo,
shared_rt_info=cg.SharedRuntimeInfo(run_id='1', device=cg.Sycamore23),
rs=np.random.RandomState(1),
)
assert circuit is not circuit2
assert circuit != circuit2
assert all(q in cg.Sycamore23.qubit_set() for q in circuit2.all_qubits())
for k, v in mapping.items():
assert k != v
def test_hqp_missing_placement():
hqp = cg.HardcodedQubitPlacer(
{cirq.LineTopology(5): dict(enumerate(cirq.LineQubit.range(5)))})
circuit = cirq.testing.random_circuit(cirq.LineQubit.range(5),
n_moments=2,
op_density=1)
shared_rt_info = cg.SharedRuntimeInfo(run_id='example')
rs = np.random.RandomState(10)
placed_c, _ = hqp.place_circuit(circuit,
problem_topology=cirq.LineTopology(5),
shared_rt_info=shared_rt_info,
rs=rs)
assert isinstance(placed_c, cirq.AbstractCircuit)
circuit = cirq.testing.random_circuit(cirq.LineQubit.range(6),
n_moments=2,
op_density=1)
with pytest.raises(cg.CouldNotPlaceError):
hqp.place_circuit(circuit,
problem_topology=cirq.LineTopology(6),
shared_rt_info=shared_rt_info,
rs=rs)
def test_print_logger(capsys):
pl = _PrintLogger(n_total=10)
shared_rt_info = cg.SharedRuntimeInfo(run_id='hi mom')
pl.initialize()
for i in range(10):
exe_result = cg.ExecutableResult(
spec=None,
runtime_info=cg.RuntimeInfo(execution_index=i),
raw_data=cirq.Result(params=cirq.ParamResolver({}),
measurements={}),
)
pl.consume_result(exe_result, shared_rt_info)
pl.finalize()
assert capsys.readouterr().out == ('\n\r1 / 10'
'\r2 / 10'
'\r3 / 10'
'\r4 / 10'
'\r5 / 10'
'\r6 / 10'
'\r7 / 10'
'\r8 / 10'
'\r9 / 10'
'\r10 / 10\n')
def test_shared_runtime_info():
shared_rtinfo = cg.SharedRuntimeInfo(run_id='my run')
cg_assert_equivalent_repr(shared_rtinfo)
def test_shared_runtime_info():
shared_rtinfo = cg.SharedRuntimeInfo(
run_id='my run', run_start_time=datetime.datetime.now(tz=datetime.timezone.utc)
)
cg_assert_equivalent_repr(shared_rtinfo)
