Homec4science
Diffusion number_routes_multipath (master) Browse

R6360/code/python-code/exp_neely_noclick.py
8f12ec2dec8emaster

Last Change
Raw File

exp_neely_noclick.py
View Options

#! /usr/bin/python
import time
import sys
import signal
import datetime
import argparse
import os
import numpy as np
sys.path.append('/opt/aziala/experiments/experiments-lib')
import pickle
import scipy
from scipy import optimize
from random import randint
from node import *
# optimal routing based on Neely et al., Fairness and Optimal Stochastic Control for Heterogeneous Networks (ToN 2008)
default_nodes = list(range(41,63))
default_nodes.remove(52) # node 52 has been removed
Rmax = 110 # initial rate per interface (max WiFi and PLC is slightly more than 100 Mb/s)
V = 250000 # V as defined in paper
length = 1450
def str2(n):
if n < 10:
return "0"+str(n)
return str(n)
def stopExp():
global nodes
computeStats()
print("Stop experiment")
time.sleep(1)
for node in nodes:
if node.getIndex() >= 0:
node.sendCommandAuto("killall iperf")
node.unsetDirectCommands()
node.unsetTelnet()
def signal_handler(signal, frame):
stopExp()
sys.exit(0)
def set_all_nodes(nodes_int = default_nodes):
nodes = [Node(-1)]*65
for i in nodes_int:
node = Node(i)
if not node.setDirectCommands(debug=False, ind=randint(0,100)):
print(("Could not set direct commands for node" + str(i)))
continue
time.sleep(0.5)
print(("Has set direct commands for node" + str(i)))
node.sendCommandAuto("/root/stop_click_u.sh")
nodes[i]=node
time.sleep(1)
return nodes
def net_of_link(link,networks):
spl = split_link(link)
for idx,net in enumerate(networks):
if spl[0] in net and spl[1] in net:
return idx
if spl[0] in net or spl[1] in net:
print(("Error, nodes in two different networks for link" + link))
return -1
return -1
def links_from_node(link_list, node):
# extract links that have node as source
res = []
for link in link_list:
if link.startswith(str(node)):
res.append(link)
return res
def split_link(s, all_ints=False):
# split link when N1->N2T or N1T->N2T to [N1,N2,T] or [N1,T1,N2,T2] (no format verification, must happen before)
tok = s.split("->")
int_src = ""
if tok[0][-1] == "W" or tok[0][-1] == "P" or tok[0][-1] == "X":
src = int(tok[0][:-1])
int_src = tok[0][-1]
else:
src = int(tok[0])
dst = int(tok[1][:-1])
int_dst = tok[1][-1]
if all_ints and int_src != "":
return [src,int_src,dst,int_dst]
else:
return [src,dst,int_dst]
def reverse_link(link):
sl = split_link(link)
return str(sl[1])+"->"+str(sl[0])+sl[2]
def str_link(arr):
# reverse split_link
if len(arr) == 3:
return str(arr[0])+"->"+str(arr[1])+arr[2]
elif len(arr) == 4:
return str(arr[0])+"->"+str(arr[2])+arr[3]
def computePaths(all_links):
paths = []
all_paths_done = False
while not all_paths_done:
if len(paths) == 0: # first link
links = links_from_node(all_links, args.source)
paths = [[x] for x in links]
if len(links) == len(all_links): # 1-hop paths
all_paths_done = True
continue
all_paths_done = True
new_paths = []
for p in paths:
last_link = p[-1]
ll_split = split_link(last_link)
if ll_split[1] == args.destination:
new_paths.append(p)
continue
links = links_from_node(all_links, ll_split[1])
for link in links:
path = list(p)
l_split = split_link(link)
if any([(str(l_split[1]) in l) for l in path]):
# loop, continue
continue
path.append(link)
new_paths.append(path)
if split_link(link)[1] != args.destination:
all_paths_done = False
paths = new_paths
return paths
def computeStats():
global nodes
global links_used
global save_file
global link_capacities
global rate_on_links
global stable
if len(links_used) == 0:
return
total_links = {}
total_wifi = 0
total_plc = 0
total_wifi2 = 0
for links in links_used:
for link in links:
if link not in total_links:
total_links[link] = 0
total_links[link] += 1
if link[-1] == "W":
total_wifi+=1
elif link[-1] == "P":
total_plc+=1
elif link[-1] == "X":
total_wifi2+=1
all_links = list(total_links.keys())
link_rates = {}
link_rates_real = {}
links_for_paths = {}
for link in all_links:
if link[-1] == "W":
interface = "wifi"
total = total_wifi
elif link[-1] == "P":
interface = "plc"
total = total_plc
elif link[-1] == "X":
interface = "wifi2"
total = total_wifi2
prop = float(total_links[link])/total
rate = link_capacities[link]
link_rates[link] = rate*prop
if link not in link_rates_real:
tok_link = split_link(link)
add_link = str_link(split_link(link, all_ints=False))
rate = np.mean(rate_on_links[add_link])
link_rates_real[add_link] = rate
if args.verbose >= 2:
print(("Rate for link" + add_link + "is" + str(rate)))
if prop > 0.05 and rate > 1:
links_for_paths[link] = rate
if args.verbose >= 1:
print(total_links)
print(links_for_paths)
# compute paths
paths = computePaths(list(links_for_paths.keys()))
print(paths)
if save_file != "":
results = {}
results["links"] = total_links
results["link_rates"] = link_rates_real
results["paths"] = paths
results["stable"] = stable
pickle.dump(results, open(save_file, "wb"))
def exp_neely(args):
global nodes
global links_used
global save_file
global link_capacities
global rate_on_links
global stable
stable = False
links_used = []
save_file = ""
rate_on_links = {}
nodes = []
if args.max_duration > 0:
ints = "w"
if set(args.nodes_noplc) != set([n for n in args.nodes]):
ints += "p"
if set(args.nodes_nowifi2) != set([n for n in args.nodes]):
ints += "x"
now = datetime.datetime.now()
ts = str(now.year)+str2(now.month)+str2(now.day)
complete_str = ""
if not args.multi_complete:
complete_str = "_nc"
save_file = "out_neely/neely_s"+str(args.source)+"-d"+str(args.destination)+"_"+ints+complete_str+"."+ts+".data"
if os.path.isfile(save_file) and not args.overwrite:
print(("File" + save_file + "already exists, set -o to overwrite"))
stopExp()
return
print(("Experiment" + save_file))
nodes = set_all_nodes(args.nodes)
if args.verbose >= 1:
print("Compute link capacities")
capacity_plc_file = "files_neely/link_capacities_plc.data"
capacity_file = "files_neely/link_capacities.data"
interfering_links_file = "files_neely/interfering_links.data"
if not os.path.isfile(interfering_links_file):
interfering_links = {}
else:
interfering_links = pickle.load(open(interfering_links_file, "rb"))
if not os.path.isfile(capacity_file):
link_capacities = {}
else:
link_capacities = pickle.load(open(capacity_file, "rb"))
link_capacities_loc = {}
changed = False
just_measured = {}
for node1 in nodes:
if node1.getIndex() < 0:
continue
# compute link capacities: W is first WiFi channel (wlan0), P is PLC, X is second WiFi channel (wlan1)
for node2 in nodes:
if node2.getIndex()>=0 and node1 != node2: # we do not assume symmetry!
link = str(node1.getIndex())+"->"+str(node2.getIndex())
if link+"W" not in link_capacities or args.force_measurements or args.force_measurements_wifi:
changed = True
time.sleep(0.1)
link_capacities[link+"W"] = node1.getIperfCapacity(node2, interface="wifi", debug=False, ping_first=True, dur=10,dur_test=5)/1000 # in Mb/s
just_measured[link+"W"] = time.time()
if link_capacities[link+"W"] < 1: # remove very low rate links
link_capacities[link+"W"] = 0
if args.verbose >= 2:
print(("Link between %s and %s, WiFi capacity %f Mb/s"
% (str(node1), str(node2), link_capacities[link+"W"])))
link_capacities_loc[link+"W"] = int(link_capacities[link+"W"]) # only used for printing and its keys: convert to int so that prettier when printing
if node1.getIndex() not in args.nodes_noplc and node2.getIndex() not in args.nodes_noplc:
if link+"P" not in link_capacities or args.force_measurements or args.force_measurements_plc:
changed = True
time.sleep(0.1)
link_capacities[link+"P"] = node1.getIperfCapacity(node2, interface="plc", debug=False, dur=10,dur_test=5, ping_first=True)/1000 # in Mb/s
just_measured[link+"P"] = time.time()
if link_capacities[link+"P"] < 1: # remove very low rate links
link_capacities[link+"P"] = 0
if args.verbose >= 2:
print(("Link between %s and %s, PLC capacity %f Mb/s"
% (str(node1), str(node2), link_capacities[link+"P"])))
link_capacities_loc[link+"P"] = int(link_capacities[link+"P"])
if node1.getIndex() not in args.nodes_nowifi2 and node2.getIndex() not in args.nodes_nowifi2:
if link+"X" not in link_capacities or args.force_measurements or args.force_measurements_wifi2:
changed = True
time.sleep(0.1)
link_capacities[link+"X"] = node1.getIperfCapacity(node2, interface="wifi2", debug=False, ping_first=True, dur=10,dur_test=5)/1000 # in Mb/s
just_measured[link+"X"] = time.time()
if link_capacities[link+"X"] < 1: # remove very low rate links
link_capacities[link+"X"] = 0
if args.verbose >= 2:
print(("Link between %s and %s, WiFi2 capacity %f Mb/s"
% (str(node1), str(node2), link_capacities[link+"X"])))
link_capacities_loc[link+"X"] = int(link_capacities[link+"X"])
if changed:
pickle.dump(link_capacities, open(capacity_file, "wb"))
changed = False
all_links = list(link_capacities_loc.keys())
if not args.multi_complete:
if args.verbose >= 1:
print("Compute interfering links")
changed = False
if not args.force_measurements_interfering:
for link1 in list(interfering_links.keys()):
reverse_link1 = reverse_link(link1)
if reverse_link1 not in interfering_links:
interfering_links[reverse_link1] = {}
for link2 in list(interfering_links[link1].keys()):
reverse_link2 = reverse_link(link2)
if reverse_link2 not in interfering_links:
interfering_links[reverse_link2] = {}
if link2 not in interfering_links:
interfering_links[link2] = {}
interfering_links[link2][link1] = interfering_links[link1][link2]
interfering_links[reverse_link1][reverse_link2] = interfering_links[link1][link2]
interfering_links[reverse_link2][reverse_link1] = interfering_links[link1][link2]
plc_network_interference = {}
all_done = False
count_all = 0
while all_done == False:
all_done = True
count_all += 1
count_links = 0
for link1 in all_links:
count_links += 1
if link_capacities[link1] == 0:
continue
if args.verbose >= 2:
print(("%s Link %s %d out of %d (count_all is %d)"
% (repr(time.time()), link1, count_links, len(all_links),str(count_all))))
reverse_link1 = reverse_link(link1)
if link1 not in interfering_links:
interfering_links[link1] = {}
if reverse_link1 not in interfering_links:
interfering_links[reverse_link1] = {}
if link1[-1] == "W":
interface = "wifi"
elif link1[-1] == "X":
interface = "wifi2"
elif link1[-1] == "P":
interface = "plc"
else:
print(("Error with link" + link1))
continue
for link2 in all_links:
if link_capacities[link2] == 0 or link_capacities[link1] == 0:
continue
reverse_link2 = reverse_link(link2)
if reverse_link2 not in interfering_links:
interfering_links[reverse_link2] = {}
if link2 not in interfering_links:
interfering_links[link2] = {}
if link1 == link2:
interfering_links[link1][link2] = True
continue
if link1[-1] == link2[-1]: # same interface link
if link1[-1] == "P" and args.plc_networks is not None:
if link1 not in plc_network_interference:
plc_network_interference[link1] = {}
net1 = net_of_link(link1,args.plc_networks)
net2 = net_of_link(link2,args.plc_networks)
if net1 == -1 or net2 == -1:
print(("Problem in finding network of PLC links "+link1+" "+link2))
plc_network_interference[link1][link2] = False
continue
plc_network_interference[link1][link2] = (net1==net2)
if args.verbose >= 3:
print((link1+"and"+link2+"interfere:"+repr(plc_network_interference[link1][link2])))
continue
if link2 not in interfering_links[link1] or (args.force_measurements_interfering and count_all <= 1):
src1 = nodes[split_link(link1)[0]]
dst1 = nodes[split_link(link1)[1]]
src2 = nodes[split_link(link2)[0]]
dst2 = nodes[split_link(link2)[1]]
if link1 not in just_measured or (time.time() - just_measured[link1]) >= 3600: # remeasure to ensure precise result
link_capacities[link1] = src1.getIperfCapacity(dst1, interface=interface, debug=False, dur=10,dur_test=10, ping_first=True)/1000 # in Mb/s
just_measured[link1] = time.time()
if args.verbose >= 1:
print(("Link"+link1+" has capacity "+str(link_capacities[link1])+"Mb/s"))
if link_capacities[link1] <= 1:
link_capacities[link1] = 0
continue
if len(list(set([src1,dst1]) & set([src2,dst2]))) > 0: # if common nodes, they necessarily interfere
print((link1+" and "+link2+" interfere, so do "+reverse_link1+" and "+reverse_link2))
interfering_links[link1][link2] = True
interfering_links[link2][link1] = True
interfering_links[reverse_link1][reverse_link2] = True
interfering_links[reverse_link2][reverse_link1] = True
interfering_links[link1][reverse_link2] = True
interfering_links[link2][reverse_link1] = True
interfering_links[link1][reverse_link1] = True
interfering_links[link2][reverse_link2] = True
continue
changed = True
dst2.launchIperfServer()
time.sleep(0.1)
if interface == "wifi":
ip = dst2.getIPStr()
elif interface == "plc":
ip = dst2.getPLCIPStr()
elif interface == "wifi2":
ip = dst2.getWifi2IPStr()
src2.launchIperfClient(ip, block = False, duration=100)
time.sleep(2)
capa = src1.getIperfCapacity(dst1, interface=interface, debug=False, dur=5, dur_test=0)/1000 # in Mb/s
src1.sendCommandAuto("killall iperf", blocking=False)
src2.sendCommandAuto("killall iperf", blocking=False)
dst1.sendCommandAuto("killall iperf", blocking=False)
dst2.sendCommandAuto("killall iperf", blocking=False)
if capa > 1.5*link_capacities[link1]: #there is a problem
print(("Problem with measurement of link"+link1+", capacity is "+str(capa)+
" instead of "+str(link_capacities[link1])))
link_capacities[link1] = src1.getIperfCapacity(dst1, interface=interface, debug=False, dur=10,dur_test=10, ping_first=True)/1000 # in Mb/s
if args.verbose >= 1:
print(("Link "+link1+" has capacity "+str(link_capacities[link1])+" Mb/s"))
all_done = False
interfering_links[link1] = {}
continue
else:
if args.verbose >= 2:
print(("Capa for %s with %s is %f instead of %f"
% (link1, link2, capa, link_capacities[link1])))
interfering_links[link1][link2] = (capa < 0.8*link_capacities[link1]) # links interfere if capa with other link smaller than 80% of capa alone
interfering_links[link2][link1] = interfering_links[link1][link2]
interfering_links[reverse_link1][reverse_link2] = interfering_links[link1][link2]
interfering_links[reverse_link2][reverse_link1] = interfering_links[link1][link2]
interfering_links[link1][reverse_link2] = interfering_links[link1][link2]
interfering_links[link2][reverse_link1] = interfering_links[link1][link2]
interfering_links[link1][reverse_link1] = interfering_links[link1][link2]
interfering_links[link2][reverse_link2] = interfering_links[link1][link2]
if args.verbose >= 2:
if interfering_links[link1][link2]:
print((link1+" and "+link2+" interfere, so do "+reverse_link1+" and "+reverse_link2))
else:
print((link1+" and "+link2+" do not interfere"))
else: # different technologies
interfering_links[link1][link2] = False
interfering_links[link2][link1] = False
if changed:
pickle.dump(interfering_links, open(interfering_links_file, "wb"))
pickle.dump(link_capacities, open(capacity_file, "wb"))
changed = False
# add plc_network_interference
for link1 in list(plc_network_interference.keys()):
interfering_links[link1] = {}
interfering_links[link1][link1] = True
for link2 in plc_network_interference[link1]:
interfering_links[link1][link2] = plc_network_interference[link1][link2]
if args.verbose >= 3:
print(link_capacities_loc)
if args.verbose >= 4:
print(interfering_links)
if args.max_duration > 0:
t = 0
links_sending = {}
limit_src = float(Rmax*1000*1000)/(8*length)
average_on = 100
rates_src_av = []
rates_dst_av = []
avg_sent_wifi = [-1]
avg_sent_plc = [-1]
avg_sent_wifi2 = [-1]
avg_sent_all = [avg_sent_wifi,avg_sent_plc,avg_sent_wifi2]
avg_received_wifi = [-1]
avg_received_plc = [-1]
avg_received_wifi2 = [-1]
avg_received_all = [avg_received_wifi,avg_received_plc,avg_received_wifi2]
links_used = []
t_beg = time.time()
count_trials = -1
stable_thr = float(average_on)*args.interval
mean_last_rate_src = 3*Rmax
mean_last_rate_dst = 1
links = []
backlogs = [{},{},{}] # wifi, plc, wifi2
# initialize backlogs
for backlog in backlogs:
for node in nodes:
if node.getIndex() >= 0:
backlog[node] = 0
for link in all_links:
rate_on_links[link] = []
str_times = ""
interfaces = ["W", "P", "X"]
interfaces_names = ["wlan0", "eth2", "wlan1"]
count_empty_links = 0
while t < args.max_duration:
count_trials += 1
t_loc = time.time()
for arr in avg_received_all:
arr.append(0)
for link in all_links:
rate_on_links[link].append(0)
if len(rate_on_links[link]) > average_on:
rate_on_links[link].pop(0)
t_loc = time.time()
rx_packets = {}
for link in list(links_sending.keys()):
link_split = split_link(link, all_ints = True)
real_link = str_link(split_link(link, all_ints = False)) # link without src interface
node_src = nodes[link_split[0]]
node_dst = nodes[link_split[2]]
node_src.sendCommandAuto("killall iperf", blocking=False) # stop traffic
node_dst.sendCommandAuto("killall iperf", blocking=False)
if args.verbose >= 3:
print(("Kill iperf in "+str(time.time() - t_loc)+" sec"))
str_times += ("+"+str(time.time() - t_loc))
t_loc = time.time()
for link in list(links_sending.keys()):
link_split = split_link(link, all_ints = True)
real_link = str_link(split_link(link, all_ints = False)) # link without src interface
node_src = nodes[link_split[0]]
node_dst = nodes[link_split[2]]
if args.verbose >= 3:
print(("Update backlogs for link "+link))
ind_int_src = interfaces.index(link_split[1])
ind_int_dst = interfaces.index(link_split[3])
int_dst_name = interfaces_names[ind_int_dst]
t_test = time.time()
if node_dst not in rx_packets:
rx_packets[node_dst] = node_dst.getRxPackets(print_time = (args.verbose >= 3))
rcvd_packets = min(backlogs[ind_int_src][node_src], rx_packets[node_dst][int_dst_name] - links_sending[link])
if args.verbose >= 3:
print((repr(time.time()-t_beg)+("Got RxPackets: %d for link %s at %s on interface %d in %s seconds"
% (rcvd_packets, link, node_dst, int_dst_name, repr(time.time() - t_test)))))
backlogs[ind_int_src][node_src] -= rcvd_packets
if node_dst.getIndex() != args.destination:
backlogs[ind_int_dst][node_dst] += rcvd_packets
rate_on_links[real_link][-1] = float(rcvd_packets)*float(length*8)/(1000*1000)
if link_split[2] == args.destination:
avg_received_all[ind_int_dst][-1] = rcvd_packets
str_times += ("+"+str(time.time() - t_loc)+" sec")
if args.verbose >= 3:
print(("Has updated backlogs in "+repr(time.time()-t_loc)+" seconds"))
print(avg_received_all)
for idx,backlog in enumerate(backlogs):
for node in backlog:
print(("Backlog for "+node+" on interface "+str(interfaces_names[idx])+" is "+str(backlog[node])))
links_sending = {}
# flow control (exogeneous arrivals): threshold based rule (Section III-E)
for idx,interface in enumerate(interfaces):
if (args.source in args.nodes_nowifi2 and interface == "X") or (args.source in args.nodes_noplc and interface == "P"):
continue
if idx not in backlogs or nodes[args.source] not in backlogs[idx]:
continue
if backlogs[idx][nodes[args.source]] <= V:
backlogs[idx][nodes[args.source]] += int(limit_src)
avg_sent_all[idx].append(limit_src)
else:
avg_sent_all[idx].append(0)
if args.verbose >= 3:
print(("At time", t, time.time()-t_beg, "flow control:", avg_sent_wifi[-1]*args.interval,
"packets on WiFi,", avg_sent_plc[-1]*args.interval, "packets on PLC,",avg_sent_wifi2[-1]*args.interval, "packets on WiFi 2"))
for arr in avg_sent_all+avg_received_all:
if len(arr) > average_on:
arr.pop(0)
t = args.interval*round(t/args.interval) # recompute to avoid float errors
if (count_trials % round(1.0/args.interval)) == 0:
rates_src = [np.mean(arr)*float(length*8)/(1000*1000) for arr in avg_sent_all]
tot_rate_src = np.mean(avg_sent_wifi)
if args.source not in args.nodes_noplc:
tot_rate_src += np.mean(avg_sent_plc)
if args.source not in args.nodes_nowifi2:
tot_rate_src += np.mean(avg_sent_wifi2)
tot_rate_src *= float(length*8)/(1000*1000) # packet per second to Mb/s
rates_dst = [np.mean(arr)*float(length*8)/(1000*1000) for arr in avg_received_all]
tot_rate_dst = np.mean(avg_received_wifi)
if args.destination not in args.nodes_noplc:
tot_rate_dst += np.mean(avg_received_plc)
if args.destination not in args.nodes_nowifi2:
tot_rate_dst += np.mean(avg_received_wifi2)
tot_rate_dst *= float(length*8)/(1000*1000) # packet per second to Mb/s
if args.verbose >= 2:
print(("At time", t, time.time()-t_beg, "total incoming rate is", tot_rate_src,
list(map(int,rates_src)),"arrival rate is", tot_rate_dst, list(map(int,rates_dst))))
print(("Last used links", links))
print(str_times)
rates_src_av.append(tot_rate_src)
rates_dst_av.append(tot_rate_dst)
str_times = ""
if t > float(average_on)*args.interval and len(rates_src_av) > int(stable_thr/args.interval):
last_rates_src = rates_src_av[-int(stable_thr/args.interval):]
last_rates_dst = rates_dst_av[-int(stable_thr/args.interval):]
mean_last_rate_src = np.mean(last_rates_src)
mean_last_rate_dst = np.mean(last_rates_dst)
if mean_last_rate_src > 0 and mean_last_rate_dst > 0 and np.mean([abs(x-mean_last_rate_src)/mean_last_rate_src < 0.05 for x in last_rates_src]) > 0.9 and np.mean([abs(x-y)/x < 0.05 for x,y in zip(last_rates_src,last_rates_dst)]) > 0.9: # has converged if for almost all last measurements (90%): rate at source within 5%, and rate at destination within 5% of rate at source
stable = True
break
# routing, scheduling, and resource allocation
if args.multi_complete:
# if multi-complete graph, all links interfere, only one can transmit per technology: the one maximizing W_l*mu_l
Wmu_max = [0]*len(interfaces)
links_ints = ['']*len(interfaces)
for node1 in nodes:
if node1.getIndex() < 0:
continue
if args.verbose >= 3:
print(("Current backlogs for", node1, "are", [backlog[node1] for backlog in backlogs]))
for node2 in nodes:
if node2.getIndex() >= 0 and node1!=node2:
# links are W->W, P->P, W->P (uses PLC interface with packets from WiFi queue), and P->W (WiFi interface with PLC queue) [same with WiFi 2 "X"]
for idx_dst,int_dst in enumerate(interfaces):
if args.verbose >= 4:
print(("End node "+str(node2.getIndex())+int_dst))
if (int_dst == "X" and node2.getIndex() in args.nodes_nowifi2) or (int_dst == "P" and node2.getIndex() in args.nodes_noplc):
continue
for idx_src,int_src in enumerate(interfaces):
if args.verbose >= 4:
print(("Start node "+str(node1.getIndex())+int_src))
if (int_src == "X" and node1.getIndex() in args.nodes_nowifi2) or (int_src == "P" and node2.getIndex() in args.nodes_noplc):
continue
link = str(node1.getIndex())+"->"+str(node2.getIndex())+int_dst # interface of link is given by interface of dst
backlog_diff = backlogs[idx_src][node1] - backlogs[idx_dst][node2]
if backlog_diff != float("inf") and backlog_diff > 0 and backlog_diff*link_capacities[link] > Wmu_max[idx_dst]:
Wmu_max[idx_dst] = backlog_diff*link_capacities[link]
if args.verbose >= 4:
print(("Add link "+str(node1.getIndex())+int_src+"->"+str(node2.getIndex())+int_dst))
links_ints[idx_dst] = str(node1.getIndex())+int_src+"->"+str(node2.getIndex())+int_dst
scheduled_links = [l for l,W in zip(links_ints,Wmu_max) if W > 0]
else: # not multi-complete
# Resource allocation, optimize the time for each link x
t_loc = time.time()
# get schedulable vectors (W_l>0)
links_schedulable = []
c_vector = [] # vector of W_l*c_l (W_l*c_l*x_l = W_l*mu_l)
for node1 in nodes:
if node1.getIndex() < 0:
continue
for node2 in nodes:
if node2.getIndex() >= 0 and node1!=node2:
# links are W->W, P->P, W->P (uses PLC interface with packets from WiFi queue), and P->W (WiFi interface with PLC queue) [same with WiFi 2 "X"]
for idx_dst,int_dst in enumerate(interfaces):
if args.verbose >= 4:
print(("End node "+str(node2.getIndex())+int_dst))
if (int_dst == "X" and node2.getIndex() in args.nodes_nowifi2) or (int_dst == "P" and node2.getIndex() in args.nodes_noplc):
continue
for idx_src,int_src in enumerate(interfaces):
if args.verbose >= 4:
print(("Start node "+str(node1.getIndex())+int_src))
if (int_src == "X" and node1.getIndex() in args.nodes_nowifi2) or (int_src == "P" and node2.getIndex() in args.nodes_noplc):
continue
link = str(node1.getIndex())+"->"+str(node2.getIndex())+int_dst # interface of link is given by interface of dst
backlog_diff = backlogs[idx_src][node1] - backlogs[idx_dst][node2]
if args.verbose >= 4:
print(("Backlog diff is "+str(backlog_diff)+", capacity of link "+link+" is "+str(link_capacities[link])))
if backlog_diff != float("inf") and backlog_diff > 0 and link_capacities[link] > 0:
if args.verbose >= 4:
print(("Add link "+str(node1.getIndex())+int_src+"->"+str(node2.getIndex())+int_dst))
links_schedulable.append(str(node1.getIndex())+int_src+"->"+str(node2.getIndex())+int_dst)
c_vector.append(-backlog_diff*link_capacities[link])
str_times += "LP computed in "+str(time.time() - t_loc)
t_loc = time.time()
# compute matrix of interference
A = np.zeros((len(links_schedulable),len(links_schedulable)))
for i,l1 in enumerate(links_schedulable):
A[i,i] = True
for j,l2 in enumerate(links_schedulable[i+1:]):
link1 = str_link(split_link(l1, all_ints=False)) # to remove intermediate technology that does not matter for rate allocation (it matters later)
link2 = str_link(split_link(l2, all_ints=False))
if link1 not in interfering_links[link2] or link2 not in interfering_links[link1]:
if args.verbose >= 4:
print(("Unknown information for links "+link1+" and "+link2))
val = False
else:
if args.verbose >= 4:
print(("Links "+link1+" and "+link2+" interfere?"+str(interfering_links[link1][link2])))
val = interfering_links[link1][link2]
A[i,i+1+j] = val
A[i+1+j,i] = val
if args.verbose >= 4:
print(links_schedulable)
print(c_vector)
print(A)
if args.verbose >= 3:
print("Run optimization...")
scheduled_links = []
if len(A) > 0:
str_times += "+"+str(time.time() - t_loc)
t_loc = time.time()
time_alloc = scipy.optimize.linprog(c_vector, A_ub=A.tolist(), b_ub=[1]*len(links_schedulable), bounds=(0,1), options={'disp':(args.verbose >= 4)})
str_times += ("+"+str(time.time() - t_loc)+" sec")
if time_alloc.success:
if args.verbose >= 3:
print((time_alloc.x))
scheduled_links = [l for l,x in zip(links_schedulable,time_alloc.x) if round(x) == 1] # for now: round allocations
elif args.verbose >= 3:
print(("Could not solve linear program, exit with status "+str(time_alloc.status)+" "+time_alloc.message))
t_loc = time.time()
# we assume blocking interface queue: will send at saturated traffic (mitigates capacity estimation error)
links = []
rx_packets = {}
if len(scheduled_links) > 0:
count_empty_links = 0
# first get RX packets and run iperf servers ; then run iperf clients
for link in scheduled_links:
tok_link = split_link(link,all_ints=True)
node_src = nodes[tok_link[0]]
node_dst = nodes[tok_link[2]]
int_src = tok_link[1]
int_dst = tok_link[3]
interface_name = interfaces_names[interfaces.index(int_dst)]
t_test = time.time()
if node_dst not in rx_packets:
rx_packets[node_dst] = node_dst.getRxPackets(print_time = (args.verbose >= 3))
links_sending[link] = rx_packets[node_dst][interface_name]
if args.verbose >= 3:
print((t, time.time()-t_beg, "Got RxPackets", links_sending[link],"for link", link,"at",
node_dst, "on interface", interface_name, "in", time.time() - t_test, "seconds"))
node_dst.launchIperfServer(port = (6000+interfaces.index(int_dst)), style=1, logfile="iperf"+str(6000+interfaces.index(int_dst))+".log")
for link in scheduled_links:
tok_link = split_link(link,all_ints=True)
node_src = nodes[tok_link[0]]
node_dst = nodes[tok_link[2]]
int_src = tok_link[1]
int_dst = tok_link[3]
ind_src = interfaces.index(int_src)
ind_dst = interfaces.index(int_dst)
if int_dst == "W":
ip = node_dst.getIPStr()
elif int_dst == "P":
ip = node_dst.getPLCIPStr()
elif int_dst == "X":
ip = node_dst.getWifi2IPStr()
max_bytes = backlogs[ind_src][node_src]*length
node_src.sendCommandAuto("iperf -c "+ip+" -u -b "+str(Rmax)+"M -n "+str(max_bytes)+" -l "+str(length)+" -p "+str(6000+ind_dst)+" > iperf"+str(6000+interfaces.index(int_dst))+".log 2&>1", blocking=False)
if args.verbose >= 3:
print((t, time.time()-t_beg,"Uses link", link, "with capacity",
link_capacities[str_link(split_link(link, all_ints=False))]))
links.append(str_link(tok_link))
else:
count_empty_links += 1
if count_empty_links == 5:
print("No link used for 5 slots, this is an error, break")
links_used = []
break
str_times += ", computed backlogs in "+str(time.time() - t_loc)
if len(links) > 0:
links_used.append(links)
if len(links_used) > average_on:
links_used.pop(0)
time.sleep(args.interval)
t += args.interval
# end of while
for link in list(links_sending.keys()):
link_split = split_link(link, all_ints = True)
node_src = nodes[link_split[0]]
node_dst = nodes[link_split[2]]
node_src.sendCommandAuto("killall iperf", blocking=False) # stop traffic
node_dst.sendCommandAuto("killall iperf", blocking=False)
time.sleep(0.1)
# computeStats()
stopExp()
def get_args(argv=None):
parser = argparse.ArgumentParser()
parser.add_argument('-N', '--nodes', metavar='NODES', nargs='*', help="Nodes participating in the experiment (default: all)")
parser.add_argument('-i', '--interval', type=float, default=0.1, help="Interval of one trial (default 0.1 sec)")
parser.add_argument('-md', '--max_duration', type=int, default=3600, help="Maximum duration of the experiment in seconds (default 1 hour)")
parser.add_argument('-s', '--source', type=int, help="Source of the flow")
parser.add_argument('-d', '--destination', type=int, help="Destination of the flow")
parser.add_argument('-v', '--verbose', type=int, default=1, help="Verbosity level (0: nothing, 1: at the end, 2: once per second, 3: every trial)")
parser.add_argument('-f', '--force_measurements', action="store_true", help="Measure capacities even if already computed (both WiFi and PLC)")
parser.add_argument('-fw', '--force_measurements_wifi', action="store_true", help="Measure capacities even if already computed (WiFi only)")
parser.add_argument('-fw2', '--force_measurements_wifi2', action="store_true", help="Measure capacities even if already computed (WiFi2 only)")
parser.add_argument('-fp', '--force_measurements_plc', action="store_true", help="Measure capacities even if already computed (PLC only)")
parser.add_argument('-fi', '--force_measurements_interfering', action="store_true", help="Measure capacities even if already computed (interfering links only)")
parser.add_argument('-c', '--multi_complete', action="store_true", help="Assume network is multi-complete (all links of a technology interfere with each other)")
parser.add_argument('-np', '--nodes_noplc', metavar='NODES', nargs='*', help="Nodes without PLC")
parser.add_argument('-nw', '--nodes_nowifi2', metavar='NODES', nargs='*', help="Nodes without second channel WiFi")
parser.add_argument('-o', '--overwrite', action="store_true", help="Overwrite file")
parser.add_argument('-p', '--plc_networks', help="Provides PLC networks for interference map, seperated by commas")
args = parser.parse_args(argv)
if args.nodes is None:
args.nodes = default_nodes
else:
nodes = []
for s in args.nodes:
if ".." in s:
tokens = s.split('..')
if len(tokens) != 2:
print("Error in nodes format")
sys.exit(0)
nodes = nodes+list(range(int(tokens[0]), int(tokens[1])+1))
else:
nodes.append(int(s))
nodes = list(set(nodes))
nodes.sort()
args.nodes = nodes
if args.plc_networks is not None:
nets_str = args.plc_networks.split(',')
nets = []
for net_s in nets_str:
network = []
net = net_s.split(" ")
for n in net:
if ".." in n:
tokens = n.split('..')
if len(tokens) != 2:
print("Error in nodes format")
sys.exit(0)
network += list(range(int(tokens[0]), int(tokens[1])+1))
else:
network.append(int(n))
nets.append(network)
args.plc_networks = nets
if args.max_duration > 0 and (args.source is None or args.destination is None):
print("With positive duration, should provide source and destination")
sys.exit(0)
if args.nodes_noplc is None:
args.nodes_noplc = []
elif "all" in args.nodes_noplc:
args.nodes_noplc = args.nodes
else:
args.nodes_noplc = list(map(int,args.nodes_noplc))
if args.nodes_nowifi2 is None:
args.nodes_nowifi2 = []
elif "all" in args.nodes_nowifi2:
args.nodes_nowifi2 = args.nodes
else:
args.nodes_nowifi2 = list(map(int,args.nodes_nowifi2))
return args
if __name__ == "__main__":
args = get_args()
signal.signal(signal.SIGINT, signal_handler)
exp_neely(args)
c4science · Help