sam.hadow/simulation-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

loss rate

Browse Source
This commit is contained in:
Sam Hadow
2025-05-06 11:18:26 +02:00
parent e4fb271614
commit a722831d97
2 changed files with 93 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/main.py
View File

@@ -1,6 +1,6 @@
#!/bin/python3
import argparse
from simulation import simulation_wrapper
from simulation import simulation_wrapper2
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Simulation server cluster')
@@ -18,5 +18,5 @@ if __name__ == "__main__":
lambda_vals = [l/100 for l in range(1, 301)] # λ from 0.01 to 3.00
simulation_wrapper(args.simulation_time, args.num_runs, args.min_runs, args.confidence_level, lambda_vals)
simulation_wrapper2(args.simulation_time, args.num_runs, args.min_runs, args.confidence_level, lambda_vals)

101
src/simulation.py
View File

@@ -57,7 +57,7 @@ class Simulation:
heappush(self.event_queue, (arrival_time, request_event))
def handle_request(self, request):
def handle_request(self, request, max_loss_value):
self.total_requests += 1
if len(self.router_queue) == 0 and self.router_state == "idle":
self.router_process(request)
@@ -66,7 +66,7 @@ class Simulation:
else:
self.lost_requests += 1
self.loss_rate = self.lost_requests / self.total_requests
if self.loss_rate > 0.05 :
if self.loss_rate > max_loss_value :
raise ValueError("lossrate too high")
def router_process(self, request):
@@ -113,7 +113,7 @@ class Simulation:
self.router_process_next()
def run(self, max_time):
def run(self, max_time, max_loss_value):
# first request
self.next_request()
@@ -123,7 +123,7 @@ class Simulation:
match current_event[1].event_type:
case "request":
self.next_request()
self.handle_request(current_event[1].request)
self.handle_request(current_event[1].request, max_loss_value)
case "router_finish":
self.router_process_finish(current_event[1].request)
case "process_finish":
@@ -134,12 +134,12 @@ class Simulation:
def run_single_simulation(args):
c, lambda_val, simulation_time = args
c, lambda_val, simulation_time, max_loss_value = args
# for different seed in each process
random.seed(time.time() + os.getpid())
try:
sim = Simulation(c, lambda_val)
sim.run(simulation_time)
sim.run(simulation_time, max_loss_value)
if len(sim.response_times) > 0:
run_mean = sum(sim.response_times) / len(sim.response_times)
loss_rate = sim.loss_rate
@@ -149,12 +149,13 @@ def run_single_simulation(args):
except ValueError: # Loss rate too high
return None
def simulation_wrapper(simulation_time, num_runs, min_runs, confidence_level, lambda_vals):
def simulation_wrapper1(simulation_time, num_runs, min_runs, confidence_level, lambda_vals):
C_values = [1, 2, 3, 6]
plt.figure(figsize=(12, 8))
mean_at_lambda1 = {}
loss_data = {}
with Pool() as pool: # pool of workers
for c in C_values:
@@ -162,11 +163,12 @@ def simulation_wrapper(simulation_time, num_runs, min_runs, confidence_level, la
means = []
ci_lower = []
ci_upper = []
losses = []
print(f"\nProcessing C={c}")
for lambda_val in lambda_vals:
# run num_runs simulation for each lambda
args_list = [(c, lambda_val, simulation_time) for _ in range(num_runs)]
args_list = [(c, lambda_val, simulation_time, 0.05) for _ in range(num_runs)]
results = pool.map(run_single_simulation, args_list)
# collect results from successful simulations
@@ -193,8 +195,9 @@ def simulation_wrapper(simulation_time, num_runs, min_runs, confidence_level, la
means.append(mean_rt)
ci_lower.append(mean_rt - ci)
ci_upper.append(mean_rt + ci)
losses.append(mean_loss)
print(f"C={c}, λ={lambda_val:.2f}, Mean RT={mean_rt:.2f} ± {ci:.2f}, Loss Rate={mean_loss:.2%}")
print(f"C={c}, λ={lambda_val:.2f}, Mean RT={mean_rt:.2f} ± {ci:.2f}, Mean Loss Rate={mean_loss:.2%}")
elif len(run_results) > 0:
print(f"λ={lambda_val:.2f} skipped - only {len(run_results)} successful run(s)")
continue
@@ -210,6 +213,8 @@ def simulation_wrapper(simulation_time, num_runs, min_runs, confidence_level, la
idx = lambda_points.index(1)
mean_at_lambda1[c] = (means[idx], ci_lower[idx], ci_upper[idx])
loss_data[c] = (np.array(lambda_points), np.array(losses))
# determine optimal C for lamba = 1
if mean_at_lambda1:
sorted_C = sorted(mean_at_lambda1.items(), key=lambda item: item[1][0])
@@ -229,4 +234,80 @@ def simulation_wrapper(simulation_time, num_runs, min_runs, confidence_level, la
plt.title(f'Mean Response Time vs Arrival Rate ({num_runs} runs, 95% CI)')
plt.legend()
plt.grid(True)
plt.show()
return loss_data
def simulation_wrapper2(simulation_time, num_runs, min_runs, confidence_level, lambda_vals, max_loss_value=0.1):
loss_data = simulation_wrapper1(simulation_time, num_runs, min_runs, confidence_level, lambda_vals)
plt.show()
for c, (lams, losses) in loss_data.items():
lambda_vals2 = []
if len(lams)==0:
print(f"C={c}: no data at all.")
continue
pos_idx = np.where(losses > 0)[0]
if pos_idx.size > 0:
first_lambda = lams[pos_idx[0]]
else:
first_lambda = None
last_lambda = lams[-1]
print(f"C={c:>1} first λ with loss > 0: "
f"{first_lambda if first_lambda is not None else 'never'}; "
f" last λ with data: {last_lambda}")
lambda_vals2.extend([last_lambda + i/1000 for i in range(-100,51)])
lambda_points = []
losses = []
ci_lower = []
ci_upper = []
print(f"\nProcessing C={c}")
with Pool() as pool:
for lambda_val in lambda_vals2:
args_list = [(c, lambda_val, simulation_time, max_loss_value) for _ in range(num_runs)]
results = pool.map(run_single_simulation, args_list)
successful_results = [res for res in results if res is not None]
loss_rates = [res[1] for res in successful_results]
n = len(loss_rates)
if n >= min_runs:
# statistics
mean_loss = np.mean(loss_rates)
std_dev = np.std(loss_rates, ddof=1)
# confidence interval
t_value = t.ppf((1 + confidence_level)/2, n-1)
ci = t_value * std_dev / np.sqrt(n)
# store results
lambda_points.append(lambda_val)
losses.append(mean_loss)
ci_lower.append(mean_loss - ci)
ci_upper.append(mean_loss + ci)
print(f"C={c}, λ={lambda_val:.4f}, Mean Loss Rate={mean_loss:.2%} ± {ci:.2f}")
elif n > 0:
print(f"λ={lambda_val:.4f} skipped - only {n} successful run(s)")
continue
else:
print(f"Stopped at λ={lambda_val:.4f} - no successful run")
break
plt.plot(lambda_points, losses, label=f'C={c}')
plt.fill_between(lambda_points, ci_lower, ci_upper, alpha=0.2)
plt.xlabel('Arrival Rate (λ)')
plt.ylabel('Mean Loss Rate')
plt.title(f'Mean Loss Rate vs Arrival Rate ({num_runs} runs, 95% CI)')
plt.legend()
plt.grid(True)
plt.show()