debug it:
import simpy
import random
import matplotlib.pyplot as plt
import numpy as np

# Parameters
num_edge_nodes = 1
edge_buffer_size = 10
cloud_buffer_size = 15

# service times
cloud_server_time = 10
A_edge_service_time = 4
A_cloud_service_time = 2
B_edge_sevice_time = 2
B_cloud_service_partialprocess = 4
B_cloud_service_fullprocess = 5
propagation_delay = 1

arrival_rate = 0.8

# Measurements
class Measure:
def init(self, N_arr_a, N_arr_b, drop, total_queuing_delay):
self.N_arr_A = N_arr_a
self.N_arr_B = N_arr_b
self.drop = drop
self.total_queuing_delay = total_queuing_delay

measurements = Measure(0, 0, 0, 0)

def packet_arrivals(env, micro_data_center, cloud_data_center, data, edge_buffer, cloud_buffer, f_value):
packet_type_options = [‘A’, ‘B’]
packet_id = 1

while True:
packet_type = random.choices(packet_type_options, weights=(1 - f_value, f_value))[0]

# Updating arrival data
if packet_type == “A”:
data.N_arr_A = data.N_arr_A + 1
else:
data.N_arr_B = data.N_arr_B + 1

arrival_time = env.now # Adding current time stamp for calculating delay
if len(micro_data_center.items) < edge_buffer:
if packet_type == ‘A’:
micro_data_center.put((packet_id, packet_type, A_edge_service_time, arrival_time))
elif packet_type == ‘B’:
micro_data_center.put((packet_id, packet_type, B_edge_sevice_time, arrival_time))
else:
if len(cloud_data_center.items) < cloud_buffer:
if packet_type == “A”:
cloud_data_center.put((packet_id, packet_type, A_cloud_service_time + propagation_delay))
elif packet_type == “B”:
cloud_data_center.put((packet_id, packet_type, B_cloud_service_fullprocess + propagation_delay))
else:
data.drop = data.drop + 1

yield env.timeout(random.expovariate(arrival_rate))
packet_id += 1


def edge_node(env, micro_data_center, cloud_data_center, node_id, data):
while True:
packet_id, packet_type, packet_processing_time, arrival_time = yield micro_data_center.get()

queuing_delay = env.now - arrival_time # Calculating delay
data.total_queuing_delay += queuing_delay
print(f"Edge Node {node_id} processed packet {packet_id} of type {packet_type} at time {env.now}“)

yield env.timeout(packet_processing_time)
if packet_type == ‘B’:
yield cloud_data_center.put((packet_id, packet_type, B_cloud_service_partialprocess + propagation_delay))

def cloud_server(env, cloud_data_center):
while True:
packet_id, packet_type, packet_processing_time = yield cloud_data_center.get()
yield env.timeout(packet_processing_time)
print(f"Cloud Server processed {packet_type} packet {packet_id} (including propagation delay) at time {env.now}”)

# Simulation setup
#f = 0.5 # Fraction of packets of type B
simtime = 100000
# Recording data

average_queuing_delays = []
f_list = np.linspace(0.001, 1, 20)
# Run the simulation
for f in f_list:
env = simpy.Environment()
micro_data_center = simpy.Store(env)
cloud_data_center = simpy.Store(env)
env.process(
packet_arrivals(env, micro_data_center, cloud_data_center, measurements, edge_buffer_size, cloud_buffer_size,f))
for node_id in range(num_edge_nodes):
env.process(edge_node(env, micro_data_center, cloud_data_center, node_id + 1, measurements))
env.process(cloud_server(env, cloud_data_center))
env.run(until=simtime)
average_queuing_delays.append(measurements.total_queuing_delay / (measurements.N_arr_A + measurements.N_arr_B))

plt.plot(f_list, average_queuing_delays)
#plt.axvline(x=2000, color=‘red’, linestyle=‘–’)
#plt.text(2000, max(losses), ‘Transition Period’, color=‘red’, va=‘bottom’, ha=‘center’)
plt.xlabel(‘Different f’)
plt.ylabel('Average queueing delay (time unit) ')
plt.title(‘Average queueing delay over Different f’)
plt.show()