Qblox bin counter algorithm

[alecandido]

"""Prototype for multi shot averaging for qblox.

This actually works in general, wherever a bin counter is used in order to save in
separate bins the various acquisition, but averaging over a single loop: the shots one.


While this loop is usually either the innermost or the outermost, the algorithm works
for the general case.

It's main advantages are that:
1. it requires only two registers
    - a bin counter, and a reset counter
2. it does not require conditional instructions
    - all the conditionals are consumed during compilation
3. it works for the general case
    - both for any placement of the shots loop
    - and for singleshot acquisition, just saving a single reset instruction
"""

import numpy as np
import numpy.typing as npt

r0 = 0
r1 = 0

Loop = tuple[int, bool]


def reset():
    global r0, r1

    r0 = 0
    r1 = 0


def loop(loops: list[Loop], singleshot: bool = False) -> npt.NDArray[np.int64]:
    global r0, r1

    lp = loops[0]

    if lp[1]:
        r1 = r0

    els = []
    for _ in range(lp[0]):
        if lp[1] and not singleshot:
            r0 = r1
        if len(loops) == 1:
            els.append(r0)
            r0 += 1
        else:
            els.append(loop(loops[1:], singleshot=singleshot))

    return np.array(els)


print("inner shots\n---\n")
print(loop([(3, False), (5, False), (4, False), (2, True)]))
reset()
print("\n\nouter shots\n---\n")
print(loop([(2, True), (3, False), (5, False), (4, False)]))
reset()
print("\n\nexotic alternative\n---\n")
print(loop([(3, False), (2, True), (5, False), (4, False)]))
reset()
print("\n\nsingle shot\n---\n")
print(loop([(2, True), (3, False), (5, False), (4, False)], singleshot=True))

[alecandido]

The looping function had to be amended.
More precisely, it was not possible to easily implement in assembly as it was, assuming the following constraints:

• only marking the shots' loop (and not its neighbors)
• the looping instructions being appended at the end of the loop
  • which is convenient for timing, since they will be processed during the experiment, or at most during its relaxation

In the end, it was possible to recover the original behavior, with a single loss: one further conditional instruction has to be introduced.

def loop(loops: list[Loop], singleshot: bool = False) -> npt.NDArray[np.int64]:
    global r0, r1

    lp = loops[0]

    els = []
    rx = lp[0]

    while rx > 0:
        if len(loops) == 1:
            els.append(r0)
            r0 += 1
        else:
            els.append(loop(loops[1:], singleshot=singleshot))

        if lp[1] and not singleshot:
            if rx > 1:
                r0 = r1
        rx -= 1

    if lp[1]:
        r1 = r0

    return np.array(els)

[alecandido]

The singleshot toggle is only required in the bin counter reset, and not in the reset counter advancement - since the r1 counter would be simply ignored in absence of the other instruction.

However, since irrelevant, the lp[1] and not singleshot condition can be combined in a unique toggle. Which eventually leads to the minimal assembly generation.