sinter 1.15.dev1745544934__tar.gz → 1.15.dev1745621353__tar.gz

{sinter-1.15.dev1745544934/src/sinter.egg-info → sinter-1.15.dev1745621353}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sinter
-Version: 1.15.dev1745544934
+Version: 1.15.dev1745621353
 Summary: Samples stim circuits and decodes them using pymatching.
 Author: Craig Gidney
 Author-email: craig.gidney@gmail.com

{sinter-1.15.dev1745544934 → sinter-1.15.dev1745621353}/setup.py

@@ -19,7 +19,7 @@ with open('README.md', encoding='UTF-8') as f:
 with open('requirements.txt', encoding='UTF-8') as f:
     requirements = f.read().splitlines()
 
-__version__ = '1.15.dev1745544934'
+__version__ = '1.15.dev1745621353'
 
 setup(
     name='sinter',

{sinter-1.15.dev1745544934 → sinter-1.15.dev1745621353}/src/sinter/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.15.dev1745544934'
+__version__ = '1.15.dev1745621353'
 
 from sinter._collection import (
     collect,

{sinter-1.15.dev1745544934 → sinter-1.15.dev1745621353}/src/sinter/_collection/_collection_manager.py

@@ -129,6 +129,10 @@ class CollectionManager:
     def start_workers(self, *, actually_start_worker_processes: bool = True):
         assert not self.started
 
+        # Use max_batch_size from collection_options if provided, otherwise default to 1024 as large
+        # batch sizes can lead to thrashing
+        max_batch_shots = self.collection_options.max_batch_size or 1024
+
         sampler = RampThrottledSampler(
             sub_sampler=MuxSampler(
                 custom_decoders=self.custom_decoders,
@@ -137,7 +141,7 @@ class CollectionManager:
                 tmp_dir=self.tmp_dir,
             ),
             target_batch_seconds=1,
-            max_batch_shots=1024,
+            max_batch_shots=max_batch_shots,
         )
 
         self.started = True

{sinter-1.15.dev1745544934 → sinter-1.15.dev1745621353}/src/sinter/_collection/_collection_test.py

@@ -1,14 +1,13 @@
 import collections
-import math
+import multiprocessing
 import pathlib
-import sys
 import tempfile
 import time
 
 import pytest
-import stim
 
 import sinter
+import stim
 
 
 def test_iter_collect():
@@ -272,3 +271,47 @@ def test_mock_timing_sampler():
         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-1.15.dev1745621353/src/sinter/_collection/_sampler_ramp_throttled_test.py

@@ -0,0 +1,144 @@
+from unittest import mock
+
+import pytest
+
+import sinter
+import stim
+from sinter._collection._sampler_ramp_throttled import (
+    CompiledRampThrottledSampler,
+    RampThrottledSampler,
+)
+from sinter._data import AnonTaskStats, Task
+
+
+class MockSampler(sinter.Sampler, sinter.CompiledSampler):
+    """Mock sampler that tracks `suggested_shots` parameter in `sample` calls."""
+
+    def __init__(self):
+        self.calls = []
+
+    def compiled_sampler_for_task(self, task: Task) -> sinter.CompiledSampler:
+        return self
+
+    def sample(self, suggested_shots: int) -> AnonTaskStats:
+        self.calls.append(suggested_shots)
+        return AnonTaskStats(
+            shots=suggested_shots,
+            errors=1,
+            seconds=0.001 * suggested_shots,  # Simulate time proportional to shots
+        )
+
+
+@pytest.fixture
+def mock_sampler():
+    return MockSampler()
+
+
+def test_initial_batch_size(mock_sampler):
+    """Test that the sampler starts with a batch size of 1."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=1.0,
+        max_batch_shots=1024,
+    )
+
+    # First call should use batch_size=1
+    sampler.sample(100)
+    assert mock_sampler.calls[0] == 1
+
+
+def test_batch_size_ramps_up(mock_sampler):
+    """Test that the batch size increases when execution is fast."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=1.0,
+        max_batch_shots=1024,
+    )
+
+    # Mock time.monotonic to simulate fast execution
+    # two calls per sample for tic/toc
+    with mock.patch(
+        "time.monotonic", side_effect=[0.0, 0.001, 0.02, 0.021, 0.03, 0.031]
+    ):
+        sampler.sample(100)  # First call, batch_size=1
+        sampler.sample(100)  # Should double 4 times to 16
+        sampler.sample(100)  # Should double 4 times again but hit limit of 100
+
+    assert mock_sampler.calls == [1, 16, 100]
+
+
+def test_batch_size_decreases(mock_sampler):
+    """Test that the batch size decreases when execution is slow."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=0.1,
+        max_batch_shots=1024,
+    )
+
+    # Set initial batch size higher for this test
+    sampler.batch_shots = 64
+
+    # Mock time.monotonic to simulate slow execution (>1.3x target)
+    with mock.patch("time.monotonic", side_effect=[0.0, 0.15, 0.5, 0.65]):
+        sampler.sample(100)  # First call, batch_size=64
+        sampler.sample(100)  # Should halve to 32
+
+    assert mock_sampler.calls == [64, 32]
+
+
+def test_respects_max_batch_shots(mock_sampler):
+    """Test that the batch size never exceeds max_batch_shots."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=1.0,
+        max_batch_shots=16,  # Small max for testing
+    )
+
+    # Set initial batch size close to max
+    sampler.batch_shots = 8
+
+    # Mock time.monotonic to simulate very fast execution
+    # two calls per sample for tic/toc
+    with mock.patch(
+        "time.monotonic", side_effect=[0.0, 0.001, 0.02, 0.021, 0.03, 0.031]
+    ):
+        sampler.sample(100)  # First call, batch_size=8
+        sampler.sample(100)  # Should double to 16
+        sampler.sample(100)  # Should stay at 16 (max)
+
+    assert mock_sampler.calls == [8, 16, 16]
+
+
+def test_respects_max_shots_parameter(mock_sampler):
+    """Test that the sampler respects the max_shots parameter."""
+    sampler = CompiledRampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=1.0,
+        max_batch_shots=1024,
+    )
+
+    # Set batch size higher than max_shots
+    sampler.batch_shots = 100
+
+    # Call with max_shots=10
+    sampler.sample(10)
+
+    # Should only request 10 shots, not 100
+    assert mock_sampler.calls[0] == 10
+
+
+def test_sub_sampler_parameter_pass_through(mock_sampler):
+    """Test that parameters are passed through to compiled sub sampler."""
+    factory = RampThrottledSampler(
+        sub_sampler=mock_sampler,
+        target_batch_seconds=0.5,
+        max_batch_shots=512,
+    )
+
+    task = Task(circuit=stim.Circuit(), decoder="test")
+    compiled = factory.compiled_sampler_for_task(task)
+
+    assert isinstance(compiled, CompiledRampThrottledSampler)
+    assert compiled.target_batch_seconds == 0.5
+    assert compiled.max_batch_shots == 512
+    assert compiled.batch_shots == 1  # Initial batch size

{sinter-1.15.dev1745544934 → sinter-1.15.dev1745621353/src/sinter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sinter
-Version: 1.15.dev1745544934
+Version: 1.15.dev1745621353
 Summary: Samples stim circuits and decodes them using pymatching.
 Author: Craig Gidney
 Author-email: craig.gidney@gmail.com

{sinter-1.15.dev1745544934 → sinter-1.15.dev1745621353}/src/sinter.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/sinter/_collection/_collection_worker_test.py
 src/sinter/_collection/_mux_sampler.py
 src/sinter/_collection/_printer.py
 src/sinter/_collection/_sampler_ramp_throttled.py
+src/sinter/_collection/_sampler_ramp_throttled_test.py
 src/sinter/_command/__init__.py
 src/sinter/_command/_main.py
 src/sinter/_command/_main_collect.py