def build_sequence_branch(self,
delegator: sequencing.SequencingElement,
if_branch: sequencing.SequencingElement,
else_branch: sequencing.SequencingElement,
sequencer: sequencing.Sequencer,
parameters: Dict[str, Parameter],
conditions: Dict[str, Condition],
measurement_mapping: Dict[str, str],
channel_mapping: Dict[ChannelID, ChannelID],
instruction_block: InstructionBlock) -> None:
if_block = InstructionBlock()
else_block = InstructionBlock()
instruction_block.add_instruction_cjmp(self.__trigger, if_block)
sequencer.push(if_branch, parameters, conditions, window_mapping=measurement_mapping,
channel_mapping=channel_mapping,
target_block=if_block)
instruction_block.add_instruction_goto(else_block)
sequencer.push(else_branch, parameters, conditions, window_mapping=measurement_mapping,
channel_mapping=channel_mapping,
target_block=else_block)
if_block.return_ip = InstructionPointer(instruction_block,
len(instruction_block.instructions))
else_block.return_ip = if_block.return_ip
def build_sequence(self, sequencer: Sequencer, parameters: Dict[str,
Parameter],
conditions: Dict[str, Condition],
measurement_mapping: Dict[str, Optional[str]],
channel_mapping: Dict[ChannelID, Optional[ChannelID]],
instruction_block: InstructionBlock) -> None:
self.validate_parameter_constraints(parameters=parameters)
body_block = InstructionBlock()
body_block.return_ip = InstructionPointer(instruction_block,
len(instruction_block))
try:
real_parameters = {
v: parameters[v].get_value()
for v in self._repetition_count.variables
}
except KeyError:
raise ParameterNotProvidedException(
next(v for v in self.repetition_count.variables
if v not in parameters))
self.insert_measurement_instruction(
instruction_block,
parameters=parameters,
measurement_mapping=measurement_mapping)
instruction_block.add_instruction_repj(
self.get_repetition_count_value(real_parameters), body_block)
sequencer.push(self.body,
parameters=parameters,
conditions=conditions,
window_mapping=measurement_mapping,
channel_mapping=channel_mapping,
target_block=body_block)
def test_empty_returning_main_block(self) -> None:
block = InstructionBlock()
self.assertEqual(0, block.get_start_address())
self.assertIsNone(block.return_ip)
ip = InstructionPointer(InstructionBlock(), 7)
block.return_ip = ip # must have no effect
self.__verify_block(block, [], [STOPInstruction()])
def test_empty_relative_block(self) -> None:
return_block = InstructionBlock()
block = InstructionBlock(return_block)
self.assertRaises(InstructionBlockNotYetPlacedException, block.get_start_address)
self.assertRaises(MissingReturnAddressException, block.compile_sequence)
ip = InstructionPointer(return_block, 7)
block.return_ip = ip
self.__verify_block(block, [], [GOTOInstruction(ip.block, ip.offset)])
def test_nested_goto(self) -> None:
parent_block = InstructionBlock()
block = InstructionBlock()
block.return_ip = InstructionPointer(parent_block, 1)
parent_block.add_instruction_goto(block)
context = dict()
immutable_block = ImmutableInstructionBlock(parent_block, context)
self.__verify_block(parent_block, immutable_block, context)
def test_create_embedded_block(self) -> None:
parent_block = InstructionBlock()
block = InstructionBlock()
block.return_ip = InstructionPointer(parent_block, 18)
self.__verify_block(
block, [], [GOTOInstruction(InstructionPointer(parent_block, 18))],
InstructionPointer(parent_block, 18))
self.__verify_block(parent_block, [], [STOPInstruction()], None)
def test_empty_returning_block(self) -> None:
return_block = InstructionBlock()
block = InstructionBlock()
block.return_ip = InstructionPointer(return_block, 7)
context = {
return_block: ImmutableInstructionBlock(return_block, dict())
}
immutable_block = ImmutableInstructionBlock(block, context)
self.__verify_block(block, immutable_block, context)
def build_sequence_branch(self, delegator: SequencingElement,
if_branch: SequencingElement,
else_branch: SequencingElement,
sequencer: Sequencer,
parameters: Dict[str, Parameter],
conditions: Dict[str, Condition],
instruction_block: InstructionBlock) -> None:
if_block = InstructionBlock()
else_block = InstructionBlock()
instruction_block.add_instruction_cjmp(self.__trigger, if_block)
sequencer.push(if_branch, parameters, conditions, if_block)
instruction_block.add_instruction_goto(else_block)
sequencer.push(else_branch, parameters, conditions, else_block)
if_block.return_ip = InstructionPointer(
instruction_block, len(instruction_block.instructions))
else_block.return_ip = if_block.return_ip
def test_multiple_nested_block_construction(self) -> None:
main_block = InstructionBlock()
blocks = []
waveforms = [DummyWaveform(), DummyWaveform(), DummyWaveform()]
main_block.add_instruction_exec(waveforms[0])
block = InstructionBlock()
trigger = Trigger()
ip = InstructionPointer(block)
main_block.add_instruction_cjmp(trigger, block)
block.return_ip = InstructionPointer(main_block, len(main_block))
blocks.append(block)
block = InstructionBlock()
trigger = Trigger()
ip = InstructionPointer(block)
main_block.add_instruction_cjmp(trigger, block)
block.return_ip = InstructionPointer(main_block, len(main_block))
blocks.append(block)
WAVEFORM_LOOKUP = [[2, 2, 1, 1], [0, 1, 1, 0, 2, 1]]
for i in [0, 1]:
block = blocks[i]
lookup = WAVEFORM_LOOKUP[i]
for id in lookup:
waveform = waveforms[id]
block.add_instruction_exec(waveform)
block = InstructionBlock()
ip = InstructionPointer(block)
blocks[0].add_instruction_cjmp(trigger, block)
block.return_ip = InstructionPointer(blocks[0], len(blocks[0]))
blocks.append(block)
for id in [1, 2, 0, 2]:
waveform = waveforms[id]
block.add_instruction_exec(waveform)
context = dict()
immutable_block = ImmutableInstructionBlock(main_block, context)
self.__verify_block(main_block, immutable_block, context.copy())
def build_sequence_loop(self, delegator: SequencingElement,
body: SequencingElement, sequencer: Sequencer,
parameters: Dict[str, Parameter],
conditions: Dict[str, Condition],
instruction_block: InstructionBlock) -> None:
body_block = InstructionBlock()
body_block.return_ip = InstructionPointer(
instruction_block, len(instruction_block.instructions))
instruction_block.add_instruction_cjmp(self.__trigger, body_block)
sequencer.push(body, parameters, conditions, body_block)
def test_nested_no_context_argument(self) -> None:
parent_block = InstructionBlock()
block = InstructionBlock()
block.return_ip = InstructionPointer(parent_block, 1)
parent_block.add_instruction_goto(block)
immutable_block = ImmutableInstructionBlock(parent_block)
context = {
parent_block: immutable_block,
block: immutable_block.instructions[0].target.block
}
self.__verify_block(parent_block, immutable_block, context)
def build_sequence_loop(self,
delegator: sequencing.SequencingElement,
body: sequencing.SequencingElement,
sequencer: sequencing.Sequencer,
parameters: Dict[str, Parameter],
conditions: Dict[str, Condition],
measurement_mapping: Dict[str, str],
channel_mapping: Dict[ChannelID, ChannelID],
instruction_block: InstructionBlock) -> None:
body_block = InstructionBlock()
body_block.return_ip = InstructionPointer(instruction_block,
len(instruction_block.instructions))
instruction_block.add_instruction_cjmp(self.__trigger, body_block)
sequencer.push(body, parameters, conditions, window_mapping=measurement_mapping,
channel_mapping=channel_mapping,
target_block=body_block)
def build_sequence(self, sequencer: Sequencer, parameters: Dict[str,
Parameter],
conditions: Dict[str, Condition],
instruction_block: InstructionBlock) -> None:
repetition_count = self.__repetition_count
if isinstance(repetition_count, ParameterDeclaration):
repetition_count = repetition_count.get_value(parameters)
if not repetition_count.is_integer():
raise ParameterNotIntegerException(
self.__repetition_count.name, repetition_count)
body_block = InstructionBlock()
body_block.return_ip = InstructionPointer(instruction_block,
len(instruction_block))
instruction_block.add_instruction_repj(int(repetition_count),
body_block)
sequencer.push(self.body, parameters, conditions, body_block)
def test_nested_block_construction(self) -> None:
main_block = InstructionBlock()
expected_instructions = [[], [], [], []]
expected_compiled_instructions = [[], [], [], []]
expected_return_ips = [None]
blocks = []
waveforms = [DummyWaveform(), DummyWaveform(), DummyWaveform()]
main_block.add_instruction_exec(waveforms[0])
expected_instructions[0].append(EXECInstruction(waveforms[0]))
block = InstructionBlock()
trigger = Trigger()
ip = InstructionPointer(block)
main_block.add_instruction_cjmp(trigger, block)
expected_instructions[0].append(CJMPInstruction(trigger, ip))
block.return_ip = InstructionPointer(main_block, len(main_block))
expected_return_ips.append(
InstructionPointer(main_block, len(main_block)))
blocks.append(block)
block = InstructionBlock()
trigger = Trigger()
ip = InstructionPointer(block)
main_block.add_instruction_cjmp(trigger, block)
expected_instructions[0].append(CJMPInstruction(trigger, ip))
block.return_ip = InstructionPointer(main_block, len(main_block))
expected_return_ips.append(
InstructionPointer(main_block, len(main_block)))
blocks.append(block)
WAVEFORM_LOOKUP = [[2, 2, 1, 1], [0, 1, 1, 0, 2, 1]]
for i in [0, 1]:
block = blocks[i]
lookup = WAVEFORM_LOOKUP[i]
for id in lookup:
waveform = waveforms[id]
expected_instructions[i + 1].append(EXECInstruction(waveform))
block.add_instruction_exec(waveform)
block = InstructionBlock()
ip = InstructionPointer(block)
blocks[0].add_instruction_cjmp(trigger, block)
expected_instructions[1].append(CJMPInstruction(trigger, ip))
block.return_ip = InstructionPointer(blocks[0], len(blocks[0]))
expected_return_ips.append(
InstructionPointer(blocks[0], len(blocks[0])))
blocks.append(block)
for id in [1, 2, 0, 2]:
waveform = waveforms[id]
expected_instructions[3].append(EXECInstruction(waveform))
block.add_instruction_exec(waveform)
for i in [0, 1, 2, 3]:
expected_compiled_instructions[i] = expected_instructions[i].copy()
expected_compiled_instructions[0].append(STOPInstruction())
for i in [0, 1, 2]:
expected_compiled_instructions[i + 1].append(
GOTOInstruction(blocks[i].return_ip))
positions = [0, None, None, None]
positions[3] = len(expected_compiled_instructions[1])
self.__verify_block(blocks[2], expected_instructions[3],
expected_compiled_instructions[3],
expected_return_ips[3])
self.__verify_block(blocks[1], expected_instructions[2],
expected_compiled_instructions[2],
expected_return_ips[2])
self.__verify_block(blocks[0], expected_instructions[1],
expected_compiled_instructions[1],
expected_return_ips[1])
self.__verify_block(main_block, expected_instructions[0],
expected_compiled_instructions[0],
expected_return_ips[0])
def test_empty_returning_block(self) -> None:
return_block = InstructionBlock()
block = InstructionBlock()
ip = InstructionPointer(return_block, 7)
block.return_ip = ip
self.__verify_block(block, [], [GOTOInstruction(ip)], ip)
