def main():
p = PimSwitch(16, 16)
for i in range(16):
for j in range(16):
p.receive(Packet(i, j))
print(p.schedule())
def generate_packets(self, unused_step):
for i in self.servers:
if random.random() < self.L:
if random.random() < self.Y:
j = random.choice(self.clients)
else:
j = random.choice(self.servers_except_me[i])
self.switch.receive(Packet(i, j))
for i in self.clients:
if random.random() < self.L:
if random.random() < self.X * self.S:
j = random.choice(self.servers)
else:
j = random.choice(self.clients_except_me[i])
self.switch.receive(Packet(i, j))
def send_ack(self, num):
self.log_packet("Sending ACK for seq {}".format(num))
p = Packet(packet_type=PacketType.ACK.value,
seq_num=num,
peer_ip_addr=self.peer_ip,
peer_port=self.peer_port,
payload='')
self.send_packet(p)
def run_trial():
p = PimSwitch(16, 16, num_iteration=0)
for i in range(16):
for j in range(16):
if random.random() < arrival_probability:
p.receive(Packet(i, j))
p.schedule()
return [c / p.match_counts[-1] for c in p.match_counts]
def send_syn(self):
self.peer_ip = ipaddress.ip_address(socket.gethostbyname(self.peer_addr))
self.connection = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
p = Packet(packet_type=PacketType.SYN.value,
seq_num=self.send_seq_num,
peer_ip_addr=self.peer_ip,
peer_port=self.peer_port,
payload='')
self.send_seq_num = (self.send_seq_num + 1) % (self.max_seq_num + 1)
packet_and_timer = {'packet': p, 'timer': time.time(), 'ack_timer': time.time()}
self.send_window.append(packet_and_timer)
self.send_packet(p)
self.log_packet("Sending SYN")
def message_read_worker(self):
while self.connection_status != ConnectionStatus.Closed:
data = ''
try:
data, addr = self.connection.recvfrom(1024)
except:
# This allows the thread to die, or else the thread would never end because recvfrom is blocking without a timeout
if self.connection_status == ConnectionStatus.Terminated:
self.log_packet('Message read worker terminating')
return
else:
if self.connection_timeout_count == 0 and self.peer_port != 0:
self.log_packet("Tcp connection hasn't heard from peer connection, terminating connection")
self.close()
return
else:
self.connection_timeout_count -= 1
continue
try:
p = Packet.from_bytes(data)
try:
if len(p.payload) > 0:
self.log_packet("Received Packet {} type {} with msg: {}\r\n".format(p.seq_num, PacketType(p.packet_type).name, p.payload.decode('utf-8')))
else:
self.log_packet("Received Packet {} type {} received".format(p.seq_num, PacketType(p.packet_type).name))
except:
self.log_packet("Received Packet {} type {} received".format(p.seq_num, PacketType(p.packet_type).name))
if self.connection_status != ConnectionStatus.Listening and self.peer_port != p.peer_port:
self.peer_port = p.peer_port
if p.packet_type == PacketType.SYN.value:
self.handle_syn(p, addr)
elif p.packet_type == PacketType.SYN_ACK.value:
# Check if it's a duplicate message
self.handle_syn_ack(p)
elif p.packet_type == PacketType.ACK.value and self.connection_status == ConnectionStatus.Open:
self.handle_ack(p)
elif p.packet_type == PacketType.NAK.value and self.connection_status == ConnectionStatus.Open:
self.handle_nack(p)
elif p.packet_type == PacketType.DATA.value and self.connection_status != ConnectionStatus.Listening:
if self.connection_status == ConnectionStatus.Handshake:
self.connection_status = ConnectionStatus.Open
self.handle_data(p)
except Exception:
self.log_packet("Error something went wrong in message_read_worker data is : {}".format(data))
def message_write_worker(self):
while self.connection_status == ConnectionStatus.Listening or self.connection_status == ConnectionStatus.Handshake:
pass
while self.connection_status == ConnectionStatus.Open:
self.message_queue_lock.acquire(True)
if len(self.messages_to_send) > 0:
current_message = self.messages_to_send.pop(0)
self.message_queue_lock.release()
while len(current_message) > 0:
self.send_window_lock.acquire(True)
while len(self.send_window) < self.window_size and len(current_message) > 0:
to_send = current_message[:self.payload_size]
current_message = current_message[self.payload_size:]
p = Packet(packet_type=PacketType.DATA.value,
seq_num=self.send_seq_num,
peer_ip_addr=self.peer_ip,
peer_port=self.peer_port,
payload=to_send)
# store the packet in-case we have to send it again
try:
self.log_packet("Sending packet type {} with message {}".format(PacketType(p.packet_type).name , p.payload.decode('utf-8')))
except:
self.log_packet("Sending packet type {}".format(PacketType(p.packet_type).name))
self.send_seq_num = (self.send_seq_num + 1) % (self.max_seq_num + 1)
packet_and_timer = {'packet': p, 'timer': time.time(), 'ack_timer': time.time()}
self.send_window.append(packet_and_timer)
self.log_packet("Send Window Size {}".format(len(self.send_window)))
try:
self.send_packet(p)
except:
if self.connection_status == ConnectionStatus.Terminated:
self.log_packet('Message write worker terminating')
self.send_window_lock.release()
return
# give a change for others to use the window so acks can be handled and
# we can removed things from the window
self.send_window_lock.release()
self.send_window_lock.acquire(True)
self.send_window_lock.release()
else:
self.message_queue_lock.release()
# Step 3: Input chooses one of the output queue
for input in reqs_to_inputs:
output = random.choice(reqs_to_inputs[input])
matched_inputs.append(input)
matched_outputs.append(output)
final_decision[input] = output
for _ in range(self.num_iteration):
run_sm_once()
if self.run_pim_after:
for _ in range(self.num_iteration):
run_pim_once()
return final_decision.items()
if __name__ == "__main__":
credit = np.array([[0, 1, 2, 3], [1, 2, 3, 0], [2, 3, 0, 1], [3, 0, 1, 2]])
p = StatisticalSwitch(4, 4, credit, 6, 1)
for i in range(4):
for j in range(4):
for _ in range(10):
p.receive(Packet(i, j))
print(p.schedule())
print(p.schedule())
print(p.schedule())
print(p.schedule())
print(p.schedule())
print(p.schedule())
def generate_packets(self, unused_step):
for i in self.input_ports:
if random.random() < self.load_per_input:
self.switch.receive(Packet(i, self.output_port))
def generate_packets(self, unused_step):
for i in range(self.switch.num_input):
if random.random() < self.load:
j = random.randrange(self.switch.num_output)
self.switch.receive(Packet(i, j))