def _read_database_callback(self, database_reader):
vertex_sizes = OrderedDict()
run_time_ms = database_reader.get_configuration_parameter_value(
"runtime")
machine_timestep_ms = \
database_reader.get_configuration_parameter_value(
"machine_time_step") / 1000.0
if self._send_labels is not None:
self._sender_connection = UDPEIEIOConnection()
for send_label in self._send_labels:
ip_address, port = database_reader.get_live_input_details(
send_label)
self._send_address_details[send_label] = (ip_address, port)
self._atom_id_to_key[send_label] = \
database_reader.get_atom_id_to_key_mapping(send_label)
vertex_sizes[send_label] = len(
self._atom_id_to_key[send_label])
if self._receive_labels is not None:
receivers = dict()
listeners = dict()
label_id = 0
for receive_label in self._receive_labels:
_, port, strip_sdp = database_reader.get_live_output_details(
receive_label, self._live_packet_gather_label)
if strip_sdp:
if port not in receivers:
receiver = UDPEIEIOConnection(local_port=port)
listener = ConnectionListener(receiver)
listener.add_callback(self._receive_packet_callback)
listener.start()
receivers[port] = receiver
listeners[port] = listener
else:
raise Exception("Currently, only ip tags which strip the"
" SDP headers are supported")
key_to_atom_id = \
database_reader.get_key_to_atom_id_mapping(receive_label)
for (key, atom_id) in key_to_atom_id.iteritems():
self._key_to_atom_id_and_label[key] = (
atom_id, label_id)
label_id += 1
vertex_sizes[receive_label] = len(key_to_atom_id)
for (label, vertex_size) in vertex_sizes.iteritems():
for init_callback in self._init_callbacks[label]:
init_callback(
label, vertex_size, run_time_ms, machine_timestep_ms)
def _read_database_callback(self, database_reader):
self._handle_possible_rerun_state()
vertex_sizes = OrderedDict()
run_time_ms = database_reader.get_configuration_parameter_value(
"runtime")
machine_timestep_ms = \
database_reader.get_configuration_parameter_value(
"machine_time_step") / 1000.0
if self._send_labels is not None:
self._sender_connection = UDPEIEIOConnection()
for send_label in self._send_labels:
ip_address, port = None, None
if self._partitioned_vertices:
ip_address, port = \
database_reader.get_partitioned_live_input_details(
send_label)
else:
ip_address, port = database_reader.get_live_input_details(
send_label)
self._send_address_details[send_label] = (ip_address, port)
if self._partitioned_vertices:
key, _ = database_reader.get_partitioned_live_input_key(
send_label)
self._atom_id_to_key[send_label] = {0: key}
vertex_sizes[send_label] = 1
else:
self._atom_id_to_key[send_label] = \
database_reader.get_atom_id_to_key_mapping(send_label)
vertex_sizes[send_label] = len(
self._atom_id_to_key[send_label])
if self._receive_labels is not None:
label_id = 0
for receive_label in self._receive_labels:
host, port, strip_sdp = None, None, None
if self._partitioned_vertices:
host, port, strip_sdp = \
database_reader.get_partitioned_live_output_details(
receive_label, self._live_packet_gather_label)
else:
host, port, strip_sdp = \
database_reader.get_live_output_details(
receive_label, self._live_packet_gather_label)
if strip_sdp:
if port not in self._receivers:
receiver = UDPEIEIOConnection(local_port=port)
listener = ConnectionListener(receiver)
listener.add_callback(self._receive_packet_callback)
listener.start()
self._receivers[port] = receiver
self._listeners[port] = listener
logger.info(
"Listening for traffic from {} on {}:{}".format(
receive_label, host, port))
else:
raise Exception("Currently, only ip tags which strip the"
" SDP headers are supported")
if self._partitioned_vertices:
key, _ = database_reader.get_partitioned_live_output_key(
receive_label, self._live_packet_gather_label)
self._key_to_atom_id_and_label[key] = (0, label_id)
vertex_sizes[receive_label] = 1
else:
key_to_atom_id = \
database_reader.get_key_to_atom_id_mapping(
receive_label)
for (key, atom_id) in key_to_atom_id.iteritems():
self._key_to_atom_id_and_label[key] = (atom_id,
label_id)
vertex_sizes[receive_label] = len(key_to_atom_id)
label_id += 1
for (label, vertex_size) in vertex_sizes.iteritems():
for init_callback in self._init_callbacks[label]:
init_callback(label, vertex_size, run_time_ms,
machine_timestep_ms)
print_condition = Condition()
def receive_callback(packet):
global pos_x
global pos_y
global dot
global canvas
try:
count = struct.unpack_from("B", packet, 0)[0]
for i in range(count):
key = struct.unpack_from("<H", packet, 2 + (i * 2))[0]
print_condition.acquire()
direction = directions[key]
print direction[0]
canvas.delete(dot)
pos_x += direction[1]
pos_y += direction[2]
dot = canvas.create_oval(pos_x - 5, pos_y - 5, pos_x + 5, pos_y + 5, fill="red")
print_condition.release()
except:
traceback.print_exc()
connection = ListenableUDPConnection(local_port=port)
listener = ConnectionListener(connection)
listener.add_callback(receive_callback)
listener.start()
tk.mainloop()
global pos_y
global dot
global canvas
try:
count = struct.unpack_from("B", packet, 0)[0]
for i in range(count):
key = struct.unpack_from("<H", packet, 2 + (i * 2))[0] & 0x3
print_condition.acquire()
direction = directions[key]
print direction[0]
canvas.delete(dot)
pos_x += direction[1]
pos_y += direction[2]
dot = canvas.create_oval(pos_x - 5,
pos_y - 5,
pos_x + 5,
pos_y + 5,
fill="red")
print_condition.release()
except:
traceback.print_exc()
connection = ListenableUDPConnection(local_port=port)
listener = ConnectionListener(connection)
listener.add_callback(receive_callback)
listener.start()
tk.mainloop()
