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))