sinter 1.15.0__py3-none-any.whl

sinter/_collection/_collection_manager_test.py

@@ -0,0 +1,287 @@
+import multiprocessing
+import time
+from typing import Any, List, Union
+
+import sinter
+import stim
+
+from sinter._collection._collection_manager import CollectionManager
+
+
+def _assert_drain_queue(q: multiprocessing.Queue, expected_contents: List[Any]):
+    for v in expected_contents:
+        assert q.get(timeout=0.1) == v
+    if not q.empty():
+        assert False, f'queue had another item: {q.get()=}'
+
+
+def _put_wait_not_empty(q: Union[multiprocessing.Queue, multiprocessing.SimpleQueue], item: Any):
+    q.put(item)
+    while q.empty():
+        time.sleep(0.0001)
+
+
+def test_manager():
+    log = []
+    t0 = sinter.Task(
+        circuit=stim.Circuit('H 0'),
+        detector_error_model=stim.DetectorErrorModel(),
+        decoder='fusion_blossom',
+        collection_options=sinter.CollectionOptions(max_shots=100_000_000, max_errors=100),
+        json_metadata={'a': 3},
+    )
+    t1 = sinter.Task(
+        circuit=stim.Circuit('M 0'),
+        detector_error_model=stim.DetectorErrorModel(),
+        decoder='pymatching',
+        collection_options=sinter.CollectionOptions(max_shots=10_000_000),
+        json_metadata=None,
+    )
+    manager = CollectionManager(
+        num_workers=3,
+        worker_flush_period=30,
+        tasks=[t0, t1],
+        progress_callback=log.append,
+        existing_data={},
+        collection_options=sinter.CollectionOptions(),
+        custom_decoders={},
+        allowed_cpu_affinity_ids=None,
+    )
+
+    assert manager.state_summary() == """
+worker 0: asked_to_drop_shots=0 assigned_shots=0 assigned_work_key=None
+worker 1: asked_to_drop_shots=0 assigned_shots=0 assigned_work_key=None
+worker 2: asked_to_drop_shots=0 assigned_shots=0 assigned_work_key=None
+"""
+
+    manager.start_workers(actually_start_worker_processes=False)
+    manager.shared_worker_output_queue.put(('computed_strong_id', 2, 'c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa'))
+    manager.shared_worker_output_queue.put(('computed_strong_id', 1, 'a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604'))
+    manager.start_distributing_work()
+
+    assert manager.state_summary() == """
+worker 0: asked_to_drop_shots=0 assigned_shots=100000000 assigned_work_key=a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604
+worker 1: asked_to_drop_shots=0 assigned_shots=5000000 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+worker 2: asked_to_drop_shots=0 assigned_shots=5000000 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+task task.strong_id='a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604':
+    workers_assigned=[0]
+    shot_return_requests=0
+    shots_left=100000000
+    errors_left=100
+    shots_unassigned=0
+task task.strong_id='c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa':
+    workers_assigned=[1, 2]
+    shot_return_requests=0
+    shots_left=10000000
+    errors_left=10000000
+    shots_unassigned=0
+"""
+
+    _assert_drain_queue(manager.worker_states[0].input_queue, [
+        (
+            'change_job',
+            (t0, sinter.CollectionOptions(max_errors=100), 100),
+        ),
+        (
+            'accept_shots',
+            (t0.strong_id(), 100_000_000),
+        ),
+    ])
+    _assert_drain_queue(manager.worker_states[1].input_queue, [
+        ('compute_strong_id', t0),
+        (
+            'change_job',
+            (t1, sinter.CollectionOptions(max_errors=10000000), 10000000),
+        ),
+        (
+            'accept_shots',
+            (t1.strong_id(), 5_000_000),
+        ),
+    ])
+    _assert_drain_queue(manager.worker_states[2].input_queue, [
+        ('compute_strong_id', t1),
+        (
+            'change_job',
+            (t1, sinter.CollectionOptions(max_errors=10000000), 10000000),
+        ),
+        (
+            'accept_shots',
+            (t1.strong_id(), 5_000_000),
+        ),
+    ])
+
+    assert manager.shared_worker_output_queue.empty()
+    assert log.pop() is None
+    assert log.pop() is None
+    assert not log
+    _put_wait_not_empty(manager.shared_worker_output_queue, (
+        'flushed_results',
+        2,
+        (t1.strong_id(), sinter.AnonTaskStats(
+            shots=5_000_000,
+            errors=123,
+            discards=0,
+            seconds=1,
+        )),
+    ))
+
+    assert manager.process_message()
+    assert manager.state_summary() == """
+worker 0: asked_to_drop_shots=0 assigned_shots=100000000 assigned_work_key=a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604
+worker 1: asked_to_drop_shots=2500000 assigned_shots=5000000 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+worker 2: asked_to_drop_shots=0 assigned_shots=0 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+task task.strong_id='a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604':
+    workers_assigned=[0]
+    shot_return_requests=0
+    shots_left=100000000
+    errors_left=100
+    shots_unassigned=0
+task task.strong_id='c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa':
+    workers_assigned=[1, 2]
+    shot_return_requests=1
+    shots_left=5000000
+    errors_left=9999877
+    shots_unassigned=0
+"""
+
+    assert log.pop() == sinter.TaskStats(
+        strong_id=t1.strong_id(),
+        decoder=t1.decoder,
+        json_metadata=t1.json_metadata,
+        shots=5_000_000,
+        errors=123,
+        discards=0,
+        seconds=1,
+    )
+    assert not log
+
+    _assert_drain_queue(manager.worker_states[0].input_queue, [])
+    _assert_drain_queue(manager.worker_states[1].input_queue, [
+        (
+            'return_shots',
+            (t1.strong_id(), 2_500_000),
+        ),
+    ])
+    _assert_drain_queue(manager.worker_states[2].input_queue, [])
+
+    _put_wait_not_empty(manager.shared_worker_output_queue, (
+        'returned_shots',
+        1,
+        (t1.strong_id(), 2_000_000),
+    ))
+    assert manager.process_message()
+    assert manager.state_summary() == """
+worker 0: asked_to_drop_shots=0 assigned_shots=100000000 assigned_work_key=a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604
+worker 1: asked_to_drop_shots=0 assigned_shots=3000000 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+worker 2: asked_to_drop_shots=0 assigned_shots=2000000 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+task task.strong_id='a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604':
+    workers_assigned=[0]
+    shot_return_requests=0
+    shots_left=100000000
+    errors_left=100
+    shots_unassigned=0
+task task.strong_id='c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa':
+    workers_assigned=[1, 2]
+    shot_return_requests=0
+    shots_left=5000000
+    errors_left=9999877
+    shots_unassigned=0
+"""
+
+    _assert_drain_queue(manager.worker_states[0].input_queue, [])
+    _assert_drain_queue(manager.worker_states[1].input_queue, [])
+    _assert_drain_queue(manager.worker_states[2].input_queue, [
+        (
+            'accept_shots',
+            (t1.strong_id(), 2_000_000),
+        ),
+    ])
+
+    _put_wait_not_empty(manager.shared_worker_output_queue, (
+        'flushed_results',
+        1,
+        (t1.strong_id(), sinter.AnonTaskStats(
+            shots=3_000_000,
+            errors=444,
+            discards=1,
+            seconds=2,
+        ))
+    ))
+    assert manager.process_message()
+    assert manager.state_summary() == """
+worker 0: asked_to_drop_shots=0 assigned_shots=100000000 assigned_work_key=a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604
+worker 1: asked_to_drop_shots=0 assigned_shots=0 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+worker 2: asked_to_drop_shots=1000000 assigned_shots=2000000 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+task task.strong_id='a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604':
+    workers_assigned=[0]
+    shot_return_requests=0
+    shots_left=100000000
+    errors_left=100
+    shots_unassigned=0
+task task.strong_id='c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa':
+    workers_assigned=[1, 2]
+    shot_return_requests=1
+    shots_left=2000000
+    errors_left=9999433
+    shots_unassigned=0
+"""
+
+    _put_wait_not_empty(manager.shared_worker_output_queue, (
+        'flushed_results',
+        2,
+        (t1.strong_id(), sinter.AnonTaskStats(
+            shots=2_000_000,
+            errors=555,
+            discards=2,
+            seconds=2.5,
+        ))
+    ))
+    assert manager.process_message()
+    assert manager.state_summary() == """
+worker 0: asked_to_drop_shots=0 assigned_shots=100000000 assigned_work_key=a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604
+worker 1: asked_to_drop_shots=0 assigned_shots=0 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+worker 2: asked_to_drop_shots=1000000 assigned_shots=0 assigned_work_key=c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa
+task task.strong_id='a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604':
+    workers_assigned=[0]
+    shot_return_requests=0
+    shots_left=100000000
+    errors_left=100
+    shots_unassigned=0
+task task.strong_id='c03f7852e4579e2a99cefac80eeb6b09556907540ab3d7787a3d07309c3333aa':
+    workers_assigned=[1, 2]
+    shot_return_requests=1
+    shots_left=0
+    errors_left=9998878
+    shots_unassigned=0
+"""
+
+    assert manager.shared_worker_output_queue.empty()
+    _put_wait_not_empty(manager.shared_worker_output_queue, (
+        'returned_shots',
+        2,
+        (t1.strong_id(), 0)
+    ))
+    assert manager.process_message()
+    assert manager.shared_worker_output_queue.empty()
+    assert manager.state_summary() == """
+worker 0: asked_to_drop_shots=66666666 assigned_shots=100000000 assigned_work_key=a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604
+worker 1: asked_to_drop_shots=0 assigned_shots=0 assigned_work_key=a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604
+worker 2: asked_to_drop_shots=0 assigned_shots=0 assigned_work_key=a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604
+task task.strong_id='a9165b6e4ab1053c04c017d0739a7bfff0910d62091fc9ee81716833eda7f604':
+    workers_assigned=[0, 1, 2]
+    shot_return_requests=1
+    shots_left=100000000
+    errors_left=100
+    shots_unassigned=0
+"""
+
+    _assert_drain_queue(manager.worker_states[0].input_queue, [
+        ('return_shots', (t0.strong_id(), 66666666)),
+    ])
+    _assert_drain_queue(manager.worker_states[1].input_queue, [
+        ('change_job', (t0, sinter.CollectionOptions(max_errors=100), 100)),
+    ])
+    _assert_drain_queue(manager.worker_states[2].input_queue, [
+        ('return_shots', (t1.strong_id(), 1000000)),
+        ('change_job', (t0, sinter.CollectionOptions(max_errors=100), 100)),
+    ])

sinter/_collection/_collection_test.py

@@ -0,0 +1,317 @@
+import collections
+import multiprocessing
+import pathlib
+import tempfile
+import time
+
+import pytest
+
+import sinter
+import stim
+
+
+def test_iter_collect():
+    result = collections.defaultdict(sinter.AnonTaskStats)
+    for sample in sinter.iter_collect(
+        num_workers=2,
+        tasks=[
+            sinter.Task(
+                circuit=stim.Circuit.generated(
+                    'repetition_code:memory',
+                    rounds=3,
+                    distance=3,
+                    after_clifford_depolarization=p),
+                decoder='pymatching',
+                json_metadata={'p': p},
+                collection_options=sinter.CollectionOptions(
+                    max_shots=1000,
+                    max_errors=100,
+                    start_batch_size=100,
+                    max_batch_size=1000,
+                ),
+            )
+            for p in [0.01, 0.02, 0.03, 0.04]
+        ],
+    ):
+        for stats in sample.new_stats:
+            result[stats.json_metadata['p']] += stats.to_anon_stats()
+    assert len(result) == 4
+    for k, v in result.items():
+        assert v.shots >= 1000 or v.errors >= 100
+        assert v.discards == 0
+    assert result[0.01].errors <= 10
+    assert result[0.02].errors <= 30
+    assert result[0.03].errors <= 70
+    assert 1 <= result[0.04].errors <= 100
+
+
+def test_collect():
+    results = sinter.collect(
+        num_workers=2,
+        tasks=[
+            sinter.Task(
+                circuit=stim.Circuit.generated(
+                    'repetition_code:memory',
+                    rounds=3,
+                    distance=3,
+                    after_clifford_depolarization=p),
+                decoder='pymatching',
+                json_metadata={'p': p},
+                collection_options=sinter.CollectionOptions(
+                    max_shots=1000,
+                    max_errors=100,
+                    start_batch_size=100,
+                    max_batch_size=1000,
+                ),
+            )
+            for p in [0.01, 0.02, 0.03, 0.04]
+        ]
+    )
+    probabilities = [e.json_metadata['p'] for e in results]
+    assert len(probabilities) == len(set(probabilities))
+    d = {e.json_metadata['p']: e for e in results}
+    assert len(d) == 4
+    for k, v in d.items():
+        assert v.shots >= 1000 or v.errors >= 100
+        assert v.discards == 0
+    assert d[0.01].errors <= 10
+    assert d[0.02].errors <= 30
+    assert d[0.03].errors <= 70
+    assert 1 <= d[0.04].errors <= 100
+
+
+def test_collect_from_paths():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        tasks = []
+        for p in [0.01, 0.02, 0.03, 0.04]:
+            path = d / f'tmp{p}.stim'
+            stim.Circuit.generated(
+                'repetition_code:memory',
+                rounds=3,
+                distance=3,
+                after_clifford_depolarization=p,
+            ).to_file(path)
+            tasks.append(sinter.Task(
+                circuit_path=path,
+                decoder='pymatching',
+                json_metadata={'p': p},
+                collection_options=sinter.CollectionOptions(
+                    max_shots=1000,
+                    max_errors=100,
+                    start_batch_size=100,
+                    max_batch_size=1000,
+                ),
+            ))
+
+        results = sinter.collect(
+            num_workers=2,
+            tasks=tasks
+        )
+    probabilities = [e.json_metadata['p'] for e in results]
+    assert len(probabilities) == len(set(probabilities))
+    d = {e.json_metadata['p']: e for e in results}
+    assert len(d) == 4
+    for k, v in d.items():
+        assert v.shots >= 1000 or v.errors >= 100
+        assert v.discards == 0
+    assert d[0.01].errors <= 10
+    assert d[0.02].errors <= 30
+    assert d[0.03].errors <= 70
+    assert 1 <= d[0.04].errors <= 100
+
+
+class AlternatingPredictionsDecoder(sinter.Decoder):
+    def decode_via_files(self,
+                         *,
+                         num_shots: int,
+                         num_dets: int,
+                         num_obs: int,
+                         dem_path: pathlib.Path,
+                         dets_b8_in_path: pathlib.Path,
+                         obs_predictions_b8_out_path: pathlib.Path,
+                         tmp_dir: pathlib.Path,
+                       ) -> None:
+        bytes_per_shot = (num_obs + 7) // 8
+        with open(obs_predictions_b8_out_path, 'wb') as f:
+            for k in range(num_shots):
+                f.write((k % 3 == 0).to_bytes(length=bytes_per_shot, byteorder='little'))
+
+
+def test_collect_custom_decoder():
+    results = sinter.collect(
+        num_workers=2,
+        tasks=[
+            sinter.Task(
+                circuit=stim.Circuit("""
+                    M(0.1) 0
+                    DETECTOR rec[-1]
+                    OBSERVABLE_INCLUDE(0) rec[-1]
+                """),
+                json_metadata=None,
+            )
+        ],
+        max_shots=10000,
+        decoders=['alternate'],
+        custom_decoders={'alternate': AlternatingPredictionsDecoder()},
+    )
+    assert len(results) == 1
+    assert results[0].shots == 10000
+    assert 2500 < results[0].errors < 4000
+
+
+def test_iter_collect_list():
+    result = collections.defaultdict(sinter.AnonTaskStats)
+    for sample in sinter.iter_collect(
+        num_workers=2,
+        tasks=[
+            sinter.Task(
+                circuit=stim.Circuit.generated(
+                    'repetition_code:memory',
+                    rounds=3,
+                    distance=3,
+                    after_clifford_depolarization=p),
+                decoder='pymatching',
+                json_metadata={'p': p},
+                collection_options=sinter.CollectionOptions(
+                    max_errors=100,
+                    max_shots=1000,
+                    start_batch_size=100,
+                    max_batch_size=1000,
+                ),
+            )
+            for p in [0.01, 0.02, 0.03, 0.04]
+        ],
+    ):
+        for stats in sample.new_stats:
+            result[stats.json_metadata['p']] += stats.to_anon_stats()
+    assert len(result) == 4
+    for k, v in result.items():
+        assert v.shots >= 1000 or v.errors >= 100
+        assert v.discards == 0
+    assert result[0.01].errors <= 10
+    assert result[0.02].errors <= 30
+    assert result[0.03].errors <= 70
+    assert 1 <= result[0.04].errors <= 100
+
+
+def test_iter_collect_worker_fails():
+    with pytest.raises(RuntimeError, match="Worker failed"):
+        _ = list(sinter.iter_collect(
+            decoders=['NOT A VALID DECODER'],
+            num_workers=1,
+            tasks=iter([
+                sinter.Task(
+                    circuit=stim.Circuit.generated('repetition_code:memory', rounds=3, distance=3),
+                    collection_options=sinter.CollectionOptions(
+                        max_errors=1,
+                        max_shots=1,
+                    ),
+                ),
+            ]),
+        ))
+
+
+class FixedSizeSampler(sinter.Sampler, sinter.CompiledSampler):
+    def compiled_sampler_for_task(self, task: sinter.Task) -> sinter.CompiledSampler:
+        return self
+
+    def sample(self, suggested_shots: int) -> 'sinter.AnonTaskStats':
+        return sinter.AnonTaskStats(
+            shots=1024,
+            errors=5,
+        )
+
+
+def test_fixed_size_sampler():
+    results = sinter.collect(
+        num_workers=2,
+        tasks=[
+            sinter.Task(
+                circuit=stim.Circuit(),
+                decoder='fixed_size_sampler',
+                json_metadata={},
+                collection_options=sinter.CollectionOptions(
+                    max_shots=100_000,
+                    max_errors=1_000,
+                ),
+            )
+        ],
+        custom_decoders={'fixed_size_sampler': FixedSizeSampler()}
+    )
+    assert 100_000 <= results[0].shots <= 100_000 + 3000
+
+
+class MockTimingSampler(sinter.Sampler, sinter.CompiledSampler):
+    def compiled_sampler_for_task(self, task: sinter.Task) -> sinter.CompiledSampler:
+        return self
+
+    def sample(self, suggested_shots: int) -> 'sinter.AnonTaskStats':
+        actual_shots = -(-suggested_shots // 1024) * 1024
+        time.sleep(actual_shots * 0.00001)
+        return sinter.AnonTaskStats(
+            shots=actual_shots,
+            errors=5,
+            seconds=actual_shots * 0.00001,
+        )
+
+
+def test_mock_timing_sampler():
+    results = sinter.collect(
+        num_workers=12,
+        tasks=[
+            sinter.Task(
+                circuit=stim.Circuit(),
+                decoder='MockTimingSampler',
+                json_metadata={},
+            )
+        ],
+        max_shots=1_000_000,
+        max_errors=10_000,
+        custom_decoders={'MockTimingSampler': MockTimingSampler()},
+    )
+    assert 1_000_000 <= results[0].shots <= 1_000_000 + 12000
+
+class BatchSizeTrackingSampler(sinter.Sampler, sinter.CompiledSampler):
+    """A sampler that tracks the suggested batch size requests it receives."""
+
+    def __init__(self, batch_sizes: list[int]):
+        self.batch_sizes = batch_sizes
+
+    def compiled_sampler_for_task(self, task: sinter.Task) -> sinter.CompiledSampler:
+        return self
+
+    def sample(self, suggested_shots: int) -> sinter.AnonTaskStats:
+        self.batch_sizes.append(suggested_shots)
+        return sinter.AnonTaskStats(
+            shots=suggested_shots,
+            errors=1,
+            seconds=0.001,
+        )
+
+
+def test_ramp_throttled_sampler_respects_max_batch_size():
+    """Test that the CollectionManager instantiated RampThrottledSampler respects the `max_batch_size`
+    parameter."""
+
+    # since the RampThrottledSampler and batch sizing happens in the worker process, we need a
+    # shared list to track what goes on with the sampler
+    with multiprocessing.Manager() as manager:
+        tracking_sampler = BatchSizeTrackingSampler(manager.list())
+
+        sinter.collect(
+            num_workers=1,
+            tasks=[
+                sinter.Task(
+                    circuit=stim.Circuit(),
+                    decoder='tracking_sampler',
+                    json_metadata={'test': 'small_batch'},
+                )
+            ],
+            max_shots=10_000,
+            max_batch_size=128,  # Set a small max batch size
+            custom_decoders={'tracking_sampler': tracking_sampler},
+        )
+        # batch size should start at one and then maximum seen should be at most 128
+        assert tracking_sampler.batch_sizes[0] == 1
+        assert 1 < max(tracking_sampler.batch_sizes) <= 128

sinter/_collection/_collection_worker_loop.py

@@ -0,0 +1,35 @@
+import os
+from typing import Optional, TYPE_CHECKING
+
+from sinter._decoding import Sampler
+from sinter._collection._collection_worker_state import CollectionWorkerState
+
+if TYPE_CHECKING:
+    import multiprocessing
+
+
+def collection_worker_loop(
+    flush_period: float,
+    worker_id: int,
+    sampler: Sampler,
+    inp: 'multiprocessing.Queue',
+    out: 'multiprocessing.Queue',
+    core_affinity: Optional[int],
+    custom_error_count_key: Optional[str],
+) -> None:
+    try:
+        if core_affinity is not None and hasattr(os, 'sched_setaffinity'):
+            os.sched_setaffinity(0, {core_affinity})
+    except:
+        # If setting the core affinity fails, we keep going regardless.
+        pass
+
+    worker = CollectionWorkerState(
+        flush_period=flush_period,
+        worker_id=worker_id,
+        sampler=sampler,
+        inp=inp,
+        out=out,
+        custom_error_count_key=custom_error_count_key,
+    )
+    worker.run_message_loop()