def test_output(self):
instructions = [
MlInstruction(
address=None,
ram_write=0,
alu_opcode=0x8,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=None,
global_command=0
),
MlInstruction(
address=None,
ram_write=None,
alu_opcode=None,
input_select=None,
output_select=None,
output_enable=None,
save_core_selection=None,
comment="This has a comment.",
global_command=None
),
MlInstruction(
address=None,
ram_write=0,
alu_opcode=0x8,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment="This has a comment!",
global_command=0
),
MlInstruction(
address=0xFF,
ram_write=0,
alu_opcode=None,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=None,
global_command=0
),
]
self.outputter.output(instructions, self.output)
lines = self.output.getvalue().split("\n")
self.assertEqual(len(lines), 5) # Last index is blank line
self.assertEqual(lines[0], '00008')
self.assertEqual(lines[1], '// This has a comment.')
self.assertEqual(lines[2], '00008 // This has a comment!')
self.assertEqual(lines[3], '0ff0c')
def generate_rotate_left(asm: AsmInstruction,
instructions: List[MlInstruction]):
bits = int(asm.operands[0])
address = int(asm.operands[1])
for i in range(bits % 16):
instructions.append(
MlInstruction(address=None,
ram_write=0,
alu_opcode=0x3,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=asm.comment if i == 0 else None))
instructions.append(
MlInstruction(address=address * 4 + int(bits / 16),
ram_write=1,
alu_opcode=0x2,
input_select=None,
output_select=0,
output_enable=0,
save_core_selection=0,
comment=asm.comment if bits % 16 == 0 else None))
instructions.append(
MlInstruction(address=address * 4 + ((3 + int(bits / 16)) % 4),
ram_write=1,
alu_opcode=0x2,
input_select=None,
output_select=0,
output_enable=0,
save_core_selection=0,
comment=None))
instructions.append(
MlInstruction(address=address * 4 + ((2 + int(bits / 16)) % 4),
ram_write=1,
alu_opcode=0x2,
input_select=None,
output_select=0,
output_enable=0,
save_core_selection=0,
comment=None))
instructions.append(
MlInstruction(address=address * 4 + ((1 + int(bits / 16)) % 4),
ram_write=1,
alu_opcode=0x2,
input_select=None,
output_select=0,
output_enable=0,
save_core_selection=0,
comment=None))
def generate_read(asm: AsmInstruction, instructions: List[MlInstruction]):
address = int(asm.operands[0])
instructions.append(MlInstruction(
address=address * 4,
ram_write=0,
alu_opcode=None,
input_select=None,
output_select=1,
output_enable=1,
save_core_selection=0,
comment=asm.comment
))
instructions.append(MlInstruction(
address=address * 4 + 1,
ram_write=0,
alu_opcode=None,
input_select=None,
output_select=1,
output_enable=1,
save_core_selection=0,
comment=None
))
instructions.append(MlInstruction(
address=address * 4 + 2,
ram_write=0,
alu_opcode=None,
input_select=None,
output_select=1,
output_enable=1,
save_core_selection=0,
comment=None
))
instructions.append(MlInstruction(
address=address * 4 + 3,
ram_write=0,
alu_opcode=None,
input_select=None,
output_select=1,
output_enable=1,
save_core_selection=0,
comment=None
))
def generate_constant(asm: AsmInstruction, instructions: List[MlInstruction]):
instructions.append(
MlInstruction(address=None,
ram_write=0,
alu_opcode=0x0,
input_select=00,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=asm.comment))
def generate_transmit(asm: AsmInstruction, instructions: List[MlInstruction]):
instructions.append(
MlInstruction(address=None,
ram_write=0,
alu_opcode=None,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=asm.comment,
global_command=3))
def test_zero_instructions(self):
ml = MlInstruction(address=0,
ram_write=0,
alu_opcode=0,
input_select=0,
output_select=0,
output_enable=0,
save_core_selection=0,
comment=None)
self.assertTrue(ml.has_instruction())
def test_comment_only(self):
ml = MlInstruction(address=None,
ram_write=None,
alu_opcode=None,
input_select=None,
output_select=None,
output_enable=None,
save_core_selection=None,
comment="This has a comment.")
self.assertTrue(ml.has_comment())
self.assertFalse(ml.has_instruction())
def test_instruction_and_comment(self):
ml = MlInstruction(address=None,
ram_write=0,
alu_opcode=0x8,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment="This has a comment!")
self.assertTrue(ml.has_comment())
self.assertTrue(ml.has_instruction())
def test_instruction_only_blank_comment(self):
ml = MlInstruction(address=None,
ram_write=0,
alu_opcode=0x8,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment='')
self.assertFalse(ml.has_comment())
self.assertTrue(ml.has_instruction())
def generate_nonce(asm: AsmInstruction, instructions: List[MlInstruction]):
address = int(asm.operands[0])
instructions.append(
MlInstruction(address=address,
ram_write=0,
alu_opcode=0x0,
input_select=0,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=asm.comment))
def _generate_instruction(self, asm: AsmInstruction,
instructions: List[MlInstruction]):
if asm.operator is None: # This means that the instruction
# is only a comment
instructions.append(
MlInstruction(None, None, None, None, None, None, None,
asm.comment, None))
elif asm.operator == "Add":
return generate_add.generate_add(asm, instructions)
elif asm.operator == "Constant":
return generate_constant.generate_constant(asm, instructions)
elif asm.operator == "CoreId":
return generate_core_id.generate_core_id(asm, instructions)
elif asm.operator == "Count":
return generate_count.generate_count(asm, instructions)
elif asm.operator == "IncrementNonce":
return generate_increment_nonce.generate_increment_nonce(
asm, instructions)
elif asm.operator == "Load":
return generate_load.generate_load(asm, instructions)
elif asm.operator == "Nonce":
return generate_nonce.generate_nonce(asm, instructions)
elif asm.operator == "Read":
return generate_read.generate_read(asm, instructions)
elif asm.operator == "RotateLeft":
return generate_rotate_left.generate_rotate_left(asm, instructions)
elif asm.operator == "Save":
return generate_save.generate_save(asm, instructions)
elif asm.operator == "SaveBitCounter":
return generate_save_bit_counter.generate_save_bit_counter(
asm, instructions)
elif asm.operator == "SaveBitsOff":
return generate_save_bits_off.generate_save_bits_off(
asm, instructions)
elif asm.operator == "SaveComparator":
return generate_save_comparator.generate_save_comparator(
asm, instructions)
elif asm.operator == "SaveNonce":
return generate_save_nonce.generate_save_nonce(asm, instructions)
elif asm.operator == "SelectCore":
return generate_select_core.generate_select_core(asm, instructions)
elif asm.operator == "SelectCoreNonce":
return generate_select_core_nonce.generate_select_core_nonce(
asm, instructions)
elif asm.operator == "Transmit":
return generate_transmit.generate_transmit(asm, instructions)
elif asm.operator == "XOR":
return generate_xor.generate_xor(asm, instructions)
else:
raise NotImplementedError(
"No generation code for {} exists.".format(asm.operator))
def generate_save_bits_off(asm: AsmInstruction,
instructions: List[MlInstruction]):
address = int(asm.operands[0])
instructions.append(MlInstruction(
address=address * 4,
ram_write=1,
alu_opcode=0xE,
input_select=None,
output_select=0,
output_enable=0,
save_core_selection=0,
comment=asm.comment,
global_command=0
))
def test_constant_instruction(self):
"""Since the "Constant" instruction is zero for every field, it can
result in an edge case where it is not generated. This is because of
confusion between how Python treats None and 0. 0 == None is False,
however "if 0" and "if None" are equivalent.
"""
instruction = MlInstruction(address=0,
ram_write=0,
alu_opcode=0,
input_select=0,
output_select=0,
output_enable=0,
save_core_selection=0,
comment=None)
self.outputter._output_instruction(instruction, self.output)
lines = self.output.getvalue().split("\n")
self.assertEqual(len(lines), 2) # Last index is blank line
self.assertEqual(lines[0], '00000')
def generate_load(asm: AsmInstruction, instructions: List[MlInstruction]):
address = int(asm.operands[0])
register = asm.operands[1]
instructions.append(
MlInstruction(address=None,
ram_write=0,
alu_opcode=0x6,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=asm.comment,
global_command=0))
instructions.append(
MlInstruction(address=address * 4 + 3,
ram_write=0,
alu_opcode=0x1 if register == "Primary" else 0x5,
input_select=1,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=None,
global_command=0))
instructions.append(
MlInstruction(address=None,
ram_write=0,
alu_opcode=0x6,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=None,
global_command=0))
instructions.append(
MlInstruction(address=address * 4 + 2,
ram_write=0,
alu_opcode=0x1 if register == "Primary" else 0x5,
input_select=1,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=None,
global_command=0))
instructions.append(
MlInstruction(address=None,
ram_write=0,
alu_opcode=0x6,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=None,
global_command=0))
instructions.append(
MlInstruction(address=address * 4 + 1,
ram_write=0,
alu_opcode=0x1 if register == "Primary" else 0x5,
input_select=1,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=None,
global_command=0))
instructions.append(
MlInstruction(address=None,
ram_write=0,
alu_opcode=0x6,
input_select=None,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=None,
global_command=0))
instructions.append(
MlInstruction(address=address * 4,
ram_write=0,
alu_opcode=0x1 if register == "Primary" else 0x5,
input_select=1,
output_select=None,
output_enable=0,
save_core_selection=0,
comment=None,
global_command=0))
