do batching only in the driver instead of a method shared for all drivers

there was a loop in _core.platform.platform.py that generated batches. This takes away the possiblity to do the batching/unrolling efficiently at the driver-level. In this commit we also use the maximum number of lines to optimise the unrolling

Author: RoyStegeman

src/qibolab/_core/instruments/qblox/cluster.py

@@ -38,6 +38,7 @@
 from .validate import (
     ACQUISITION_MEMORY,
     ACQUISITION_NUMBER,
+    QCM_INSTRUCTION_MEMORY,
     assert_channels_exclusion,
     validate_sequence,
 )
@@ -144,7 +145,6 @@ def play(
         sweepers: list[ParallelSweepers],
     ) -> dict[PulseId, Result]:
         """Execute the given experiment."""
-        assert options.relaxation_time is not None
 
         results = {}
         log = Logger(configs)
@@ -155,25 +155,38 @@ def play(
             batch = []
             batch_memory = 0
             batch_acquisitions = 0
+            # an offset number of lines that is always there regardless of the nubmer of
+            # pulses played.
+            bach_instructions_memory = 50
             for ps in sequences:
                 acquisitions = len(ps.acquisitions)
                 per_shot_memory = get_per_shot_memory(ps, sweepers, options)
+                # the factor 1.59 is determined heuristically, for large number of gates
+                # and iterations the ratio of ps.data objects to Lines is approx 1.56
+                instructions_memory = len(ps.data) * 1.59
 
                 if (
-                    batch_memory + per_shot_memory > ACQUISITION_MEMORY
+                    # we take the QCM memory as limit since that is likely to have
+                    # a larger number of instructions
+                    bach_instructions_memory + instructions_memory
+                    > QCM_INSTRUCTION_MEMORY
+                    or batch_memory + per_shot_memory > ACQUISITION_MEMORY
                     or batch_acquisitions + acquisitions > ACQUISITION_NUMBER
                 ):
                     batched_list.append(batch)
                     batch = []
                     batch_memory = 0
                     batch_acquisitions = 0
+                    bach_instructions_memory = 50
 
                 batch_acquisitions += acquisitions
                 batch_memory += per_shot_memory
+                bach_instructions_memory += instructions_memory
                 batch.append(ps)
             if batch:
                 batched_list.append(batch)
 
+            assert options.relaxation_time is not None
             batched_seqs = []
             for batch in batched_list:
                 batched = batch[0]

src/qibolab/_core/instruments/qblox/config/sequencer.py

@@ -143,4 +143,4 @@ def apply(self, seq: Sequencer):
         for name in self.model_fields_set - applied:
             value = getattr(self, name)
             if value is not None:
-                seq.set(name, value)
+                seq.parameters[name].set(value)

src/qibolab/_core/instruments/qblox/utils.py

@@ -39,7 +39,7 @@ def batch_shots(
     """
     assert options.nshots is not None
 
-    if options.averaging_mode is not AveragingMode.SINGLESHOT:
+    if options.averaging_mode.average:
         return [options.nshots]
 
     per_shot_memory = get_per_shot_memory(sequence, sweepers, options)

src/qibolab/_core/instruments/qblox/validate.py

@@ -1,4 +1,5 @@
 from qibolab._core.identifier import ChannelId
+from qibolab._core.instruments.qblox.q1asm.ast_ import Line
 from qibolab._core.instruments.qblox.sequence.acquisition import Acquisition, Weight
 from qibolab._core.instruments.qblox.sequence.sequence import Q1Sequence
 from qibolab._core.sequence import PulseSequence
@@ -18,6 +19,14 @@
 https://docs.qblox.com/en/main/cluster/q1_sequence_processor.html#waveform-memory
 """
 
+QCM_INSTRUCTION_MEMORY = 2**14
+QRM_INSTRUCTION_MEMROY = 12288
+"""Maximum number of instructions per program for the QCM and QRM modules.
+
+https://docs.qblox.com/en/v0.16.0/cluster/q1_sequence_processor.html#instruction-memory
+"""
+
+
 WEIGHT_MEMORY = 2**14
 """Maximum waveform memory available.
 
@@ -74,8 +83,13 @@ def assert_acquisition_memory(acquisitions: list[Acquisition]) -> None:
     assert sum(a.num_bins for a in acquisitions) <= ACQUISITION_MEMORY
 
 
+def assert_instruction_memory(elements: list[Line]):
+    assert len(elements) <= QCM_INSTRUCTION_MEMORY
+
+
 def validate_sequence(sequence: Q1Sequence) -> None:
     """Validate sequence elements."""
+    assert_instruction_memory(list(sequence.program.elements))
     assert_acquisition_memory(list(sequence.acquisitions.values()))
     assert_waveform_memory(list(sequence.waveforms.values()))
     assert_weight_memory(list(sequence.weights.values()))

src/qibolab/_core/platform/platform.py

@@ -24,7 +24,6 @@
 from ..qubits import Qubit
 from ..sequence import PulseSequence
 from ..sweeper import ParallelSweepers
-from ..unrolling import Bounds, batch
 
 __all__ = ["Platform"]
 
@@ -267,12 +266,7 @@ def execute(
             if name in self.instruments:
                 self.instruments[name].setup(**cfg.model_dump(exclude={"kind"}))
 
-        results = {}
-        # pylint: disable=unsubscriptable-object
-        bounds = self.parameters.configs[self._controller.bounds]
-        assert isinstance(bounds, Bounds)
-        for b in batch(sequences, bounds):
-            results |= self._execute(b, options, configs, sweepers)
+        results = self._execute(sequences, options, configs, sweepers)
 
         return results