I want to modify the code in order to have two servers instead of one server. gimme the…
- User
I want to modify the code in order to have two servers instead of one server. gimme the modifications
#!/usr/bin/python3
import random from queue import Queue, PriorityQueue import matplotlib.pyplot as plt
******************************************************************************
Constants
******************************************************************************
class simulator: def init(self, service, arrival, sim_time, max_buffer_size = float('inf')): self.service = 1/service # SERVICE is the average service time; service rate = 1/SERVICE self.arrival = 1/arrival # ARRIVAL is the average inter-arrival time; arrival rate = 1/ARRIVAL self.load= self.service / self.arrival # This relationship holds for M/M/1 self.max_buffer_size = max_buffer_size self.type1 = 1 self.sim_time = sim_time self.arrivals=0 self.users=0 self.data = None self.BusyServer=False # True: server is currently busy; False: server is currently idle self.MM1= None self.FES = None self.result = None random.seed(42)
# ****************************************************************************** # To take the measurements # ****************************************************************************** class Measure: def __init__(self,Narr,Ndep,NAveraegUser,OldTimeEvent,AverageDelay,Drop): self.arr = Narr self.dep = Ndep self.ut = NAveraegUser self.oldT = OldTimeEvent self.delay = AverageDelay self.drop = Drop # ****************************************************************************** # Client # ****************************************************************************** class Client: def __init__(self,type,arrival_time): self.type = type self.arrival_time = arrival_time # ****************************************************************************** # Server # ****************************************************************************** class Server(object): # constructor def __init__(self): # whether the server is idle or not self.idle = True # ****************************************************************************** # arrivals ********************************************************************* def Arrival(self,time, queue): #print("Arrival no. ",data.arr+1," at time ",time," with ",users," users" ) # cumulate statistics self.data.arr += 1 self.data.ut += self.users*(time-self.data.oldT) self.data.oldT = time # sample the time until the next event inter_arrival = random.expovariate(lambd=1.0/self.arrival) # schedule the next arrival self.FES.put((time + inter_arrival, "arrival")) self.users += 1 # create a record for the client client = self.Client(self.type1,time) # check the buffer size before adding a new packet into the MM1 queue if len(queue) < self.max_buffer_size: queue.append(client) else: # increase the dropped packets count self.data.drop += 1 self.users -= 1 # if the server is idle start the service if self.users==1: # sample the service time service_time = random.expovariate(1.0/self.service) #service_time = 1 + random.uniform(0, SEVICE_TIME) # schedule when the client will finish the server self.FES.put((time + service_time, "departure")) # ****************************************************************************** # departures ******************************************************************* def Departure(self,time, queue): #print("Departure no. ",data.dep+1," at time ",time," with ",users," users" ) # cumulate statistics self.data.dep += 1 self.data.ut += self.users*(time-self.data.oldT) self.data.oldT = time # get the first element from the queue client = queue.pop(0) # do whatever we need to do when clients go away self.data.delay += (time-client.arrival_time) self.users -= 1 # see whether there are more clients to in the line if self.users >0: # sample the service time service_time = random.expovariate(1.0/self.service) # schedule when the client will finish the server self.FES.put((time + service_time, "departure")) # ****************************************************************************** # the "main" of the simulation # ****************************************************************************** def run(self): self.users = 0 self.result= {} self.data = self.Measure(0,0,0,0,0,0) self.MM1 = [] self.time = 0 # the list of events in the form: (time, type) self.FES = None self.FES = PriorityQueue() # schedule the first arrival at t=0 self.FES.put((0, "arrival")) # simulate until the simulated time reaches a constant while self.time < self.sim_time: (self.time, self.event_type) = self.FES.get() if self.event_type == "arrival": self.Arrival(self.time, self.MM1) elif self.event_type == "departure": self.Departure(self.time, self.MM1) # print output data print("MEASUREMENTS") print("{:<30}{}".format("No. of users in the queue:", self.users)) print("{:<30}{}".format("No. of arrivals :", self.data.arr)) print("{:<30}{}".format("No. of departures :", self.data.dep)) print("{:<30}{}".format("Dropped packets:", self.data.drop)) print("{:<30}{}".format("Loss probability:", self.data.drop / self.data.arr)) # Add this line print("{:<30}{}".format("Buffer size:", self.max_buffer_size if self.max_buffer_size != float("inf") else "infinite")) print("{:<30}{}".format("Load:", self.load )) print("{:<30}{}".format("Arrival rate:", self.data.arr / self.time)) print("{:<30}{}".format("Departure rate:", self.data.dep / self.time)) print("{:<30}{}".format("Average number of users:", self.data.ut / self.time)) print("{:<30}{}".format("Average delay:", self.data.delay / self.data.dep)) print("{:<30}{}".format("Actual queue size:", len(self.MM1))) if len(self.MM1) > 0: print("{:<30}{}".format("Arrival time of the last element in the queue:", self.MM1[len(self.MM1) - 1].arrival_time)) # Create a dictionary of data related to the simulation self.result = { "No. of users in the queue": self.users, "No. of arrivals": self.data.arr, "No. of departures": self.data.dep, "Dropped packets": self.data.drop, "Loss probability": self.data.drop / self.data.arr, "Buffer size": self.max_buffer_size if self.max_buffer_size != float("inf") else "infinite", "Load": self.load, "Arrival rate": self.data.arr / self.time, "Departure rate": self.data.dep / self.time, "Average number of users": self.data.ut / self.time, "Average delay": self.data.delay / self.data.dep, "Actual queue size": len(self.MM1) } return self.data, self.result def plot_graphs(self): # Average Delay vs. Load load_values = [self.result["Load"] for _ in range(len(self.data))] delay_values = [self.result["Average delay"] for _ in range(len(self.data))] plt.plot(load_values, delay_values) plt.xlabel("Load") plt.ylabel("Average Delay") plt.title("Average Delay vs. Load") plt.show() # Loss Probability vs. Load loss_prob_values = [self.result["Loss probability"] for _ in range(len(self.data))] plt.plot(load_values, loss_prob_values) plt.xlabel("Load") plt.ylabel("Loss Probability") plt.title("Loss Probability vs. Load") plt.show() # Utilization vs. Load utilization_values = [self.result["Average number of users"] for _ in range(len(self.data))] plt.plot(load_values, utilization_values) plt.xlabel("Load") plt.ylabel("Utilization") plt.title("Utilization vs. Load") plt.show() # Average Delay vs. Buffer Size buffer_size_values = [self.result["Buffer size"] for _ in range(len(self.data))] plt.plot(buffer_size_values, delay_values) plt.xlabel("Buffer Size") plt.ylabel("Average Delay") plt.title("Average Delay vs. Buffer Size") plt.show() # Utilization vs. Buffer Size plt.plot(buffer_size_values, utilization_values) plt.xlabel("Buffer Size") plt.ylabel("Utilization") plt.title("Utilization vs. Buffer Size") plt.show()def plot_graph(data1, data2, label1, label2, title): plt.plot(data1, data2) plt.xlabel(label1) plt.ylabel(label2) plt.title(title) plt.show()
if name == "main": # simulator inputs : service, arrival , sim_time, buffer_size packet_simulator = simulator(10,20,500000,10) arrival_rates = list(range(1, 10))[:100] finalresult = [] for i in arrival_rates: packet_simulator = simulator(10,i,500000,10) finalresult.append([packet_simulator.run()[1]])
# Loss Probability vs. Arrival Rate loss_prob_values = [result[0]["Loss probability"] for result in finalresult] plot_graph(arrival_rates, loss_prob_values, "Arrival Rate", "Loss Probability", "Loss Probability vs. Arrival Rate") # Utilization vs. Arrival Rate utilization_values = [result[0]["Average number of users"] for result in finalresult] plot_graph(arrival_rates, utilization_values, "Arrival Rate", "Utilization", "Utilization vs. Arrival Rate") # Average Delay vs. Arrival Rate delay_values = [result[0]["Average delay"] for result in finalresult] plot_graph(arrival_rates, delay_values, "Arrival Rate", "Average Delay", "Average Delay vs. Arrival Rate") - Assistant
In order to modify the code to have two servers instead of one server, you can follow these steps:
- Create two server objects in the
simulatorclass:self.server1andself.server2. - Update the Arrival and Departure methods to handle both servers.
- Update the simulation loop to account for both servers.
Here's the modified code:
class simulator: # ... (keeping the existing code) # ****************************************************************************** # Server # ****************************************************************************** class Server(object): # constructor def __init__(self): # whether the server is idle or not self.idle = True # ... (keeping the existing code) # arrivals ********************************************************************* def Arrival(self, time, queue): # ... (keeping the existing code) # if the server is idle start the service if (self.server1.idle or self.server2.idle) and len(queue) > 0: if self.server1.idle: self.server1.idle = False else: self.server2.idle = False # sample the service time service_time = random.expovariate(1.0 / self.service) # schedule when the client will finish the server self.FES.put((time + service_time, "departure")) #departures********************************************************************* def Departure(self, time, queue): # ... (keeping the existing code) # see whether there are more clients in the line if len(queue) > 0: # sample the service time service_time = random.expovariate(1.0 / self.service) # schedule when the client will finish the server self.FES.put((time + service_time, "departure")) else: if self.server1.idle == False: self.server1.idle = True else: self.server2.idle = True # ... (keeping the existing code) def run(self): self.users = 0 # create two server objects self.server1 = self.Server() self.server2 = self.Server() # ... (keeping the existing code) # simulate until the simulated time reaches a constant while self.time < self.sim_time: (self.time, self.event_type) = self.FES.get() if self.event_type == "arrival": self.Arrival(self.time, self.MM1) elif self.event_type == "departure": self.Departure(self.time, self.MM1) # ... (keeping the existing code)Now, the simulator uses two servers to process the clients in the queue.
- Create two server objects in the