def get_data(self, transceiver, placement, extra_monitor_vertices,
placements):
data = struct.pack("<I", 100)
message = SDPMessage(sdp_header=SDPHeader(
destination_chip_x=placement.x,
destination_chip_y=placement.y,
destination_cpu=placement.p,
destination_port=2,
flags=SDPFlag.REPLY_NOT_EXPECTED),
data=data)
# create socket
connection = UDPConnection(local_host=None, local_port=self.PORT)
# send
# set router time out
extra_monitor_vertices[0].set_router_time_outs(15, 15, transceiver,
placements,
extra_monitor_vertices)
transceiver.send_sdp_message(message=message)
# receive
output = None
finished = False
first = True
offset = 0
while not finished:
data = connection.receive()
length_of_data = len(data)
if first:
length = struct.unpack_from("<I", data, 0)[0]
first = False
output = bytearray(length)
self._view = memoryview(output)
self._view[offset:offset + length_of_data - 4] = \
data[4:4 + length_of_data - 4]
offset += length_of_data - 4
else:
last_mc_packet = struct.unpack_from("<I", data,
length_of_data - 4)[0]
if last_mc_packet == 0xFFFFFFFF:
self._view[offset:offset + length_of_data - 4] = \
data[0:0 + length_of_data - 4]
offset += length_of_data - 4
finished = True
else:
self._view[offset:offset + length_of_data] = \
data[0:0 + length_of_data]
offset += length_of_data
# hand back
# set router time out
extra_monitor_vertices[0].set_router_time_outs(15, 4, transceiver,
placements,
extra_monitor_vertices)
return output
def __init__(self):
super(PacketGathererWithProtocol, self).__init__(label="pg",
constraints=None)
self._view = None
self._max_seq_num = None
self._output = None
self._lost_seq_nums = list()
# create socket
self._connection = UDPConnection(local_host=None)
def get_data(self, transceiver, placement, extra_monitor_vertices,
placements):
data = struct.pack("<I", self.SDP_PACKET_START_SENDING_COMMAND_ID)
# print("sending to core {}:{}:{}".format(
# placement.x, placement.y, placement.p))
message = SDPMessage(sdp_header=SDPHeader(
destination_chip_x=placement.x,
destination_chip_y=placement.y,
destination_cpu=placement.p,
destination_port=self.SDP_PACKET_PORT,
flags=SDPFlag.REPLY_NOT_EXPECTED),
data=data)
# create socket
connection = UDPConnection(local_host=None, local_port=self.PORT)
# set router time out
extra_monitor_vertices[0].set_router_time_outs(15, 15, transceiver,
placements,
extra_monitor_vertices)
# send message
transceiver.send_sdp_message(message=message)
# receive
finished = False
first = True
seq_num = 1
seq_nums = set()
while not finished:
try:
data = connection.receive(
timeout=self.TIMEOUT_PER_RECEIVE_IN_SECONDS)
first, seq_num, seq_nums, finished = \
self._process_data(
data, first, seq_num, seq_nums, finished, placement,
transceiver)
except SpinnmanTimeoutException:
if not finished:
finished = self._transmit_missing_seq_nums(
seq_nums, transceiver, placement)
# self._check(seq_nums)
# set router time out
extra_monitor_vertices[0].set_router_time_outs(15, 4, transceiver,
placements,
extra_monitor_vertices)
connection.close()
return self._output, self._lost_seq_nums
def __init_sender(self, db, vertex_sizes):
if self.__sender_connection is None:
self.__sender_connection = UDPConnection()
for label in self.__send_labels:
self.__send_address_details[label] = self.__get_live_input_details(
db, label)
if self.__machine_vertices:
key, _ = db.get_machine_live_input_key(label)
self._atom_id_to_key[label] = {0: key}
vertex_sizes[label] = 1
else:
self._atom_id_to_key[label] = db.get_atom_id_to_key_mapping(
label)
vertex_sizes[label] = len(self._atom_id_to_key[label])
def __init__(self, responses=None):
"""
:param responses:\
An optional list of responses to send in the order to be sent. \
If not specified, OK responses will be sent for every request. \
Note that responses can include "None" which means that no\
response will be sent to that request
"""
super(MockBMP, self).__init__()
# Set up a connection to be the machine
self._receiver = UDPConnection(local_port=SCP_SCAMP_PORT)
self._running = False
self._error = None
self._responses = deque()
if responses is not None:
self._responses.extend(responses)
def get_data(self, transceiver, placement):
data = struct.pack("<I", self.SDP_PACKET_START_SENDING_COMMAND_ID)
# print("sending to core {}:{}:{}".format(
# placement.x, placement.y, placement.p))
message = SDPMessage(sdp_header=SDPHeader(
destination_chip_x=placement.x,
destination_chip_y=placement.y,
destination_cpu=placement.p,
destination_port=self.SDP_PACKET_PORT,
flags=SDPFlag.REPLY_NOT_EXPECTED),
data=data)
# create socket
connection = UDPConnection(local_host=None, local_port=self.PORT)
# send
transceiver.set_reinjection_router_timeout(15, 15)
transceiver.send_sdp_message(message=message)
# receive
finished = False
first = True
seq_num = 1
seq_nums = set()
while not finished:
try:
data = connection.receive(
timeout=self.TIMEOUT_PER_RECEIVE_IN_SECONDS)
first, seq_num, seq_nums, finished = \
self._process_data(
data, first, seq_num, seq_nums, finished, placement,
transceiver)
except SpinnmanTimeoutException:
if not finished:
finished = self._transmit_missing_seq_nums(
seq_nums, transceiver, placement)
# pretend that we're broken, re-require some of the data
print("doing fake retransmission")
missing_seq_nums = [3140, 1938]
self._remove_seq_nums(seq_nums, missing_seq_nums)
finished = self._transmit_missing_seq_nums(seq_nums, transceiver,
placement)
while not finished:
try:
data = connection.receive(
timeout=self.TIMEOUT_PER_RECEIVE_IN_SECONDS)
first, seq_num, seq_nums, finished = \
self._process_data(
data, first, seq_num, seq_nums, finished, placement,
transceiver)
except SpinnmanTimeoutException:
if not finished:
finished = self._transmit_missing_seq_nums(
seq_nums, transceiver, placement)
# self._check(seq_nums)
transceiver.set_reinjection_router_timeout(15, 4)
return self._output