def run(protocol, csvfile, step_duration, step_distance):
shared.seed_random(42)
node_count = 50
state = topology.create_nodes(node_count)
mobility.randomize_positions(state, xy_range=1000)
mobility.connect_range(state, max_links=150)
# create network and start routing software
network.apply(state, link_command=get_tc_command, remotes=remotes)
software.start(protocol)
test_beg_ms = shared.millis()
for n in range(0, 30):
print(f'{protocol}: iteration {n}')
#with open(f'graph-{step_duration}-{step_distance}-{n:03d}.json', 'w+') as file:
# json.dump(state, file, indent=' ')
# connect nodes range
wait_beg_ms = shared.millis()
# update network representation
mobility.move_random(state, distance=step_distance)
mobility.connect_range(state, max_links=150)
# update network
tmp_ms = shared.millis()
network.apply(state=state,
link_command=get_tc_command,
remotes=remotes)
#software.apply(protocol=protocol, state=state) # we do not change the node count
network_ms = shared.millis() - tmp_ms
# Wait until wait seconds are over, else error
shared.wait(wait_beg_ms, step_duration)
paths = ping.get_random_paths(state, 2 * 400)
paths = ping.filter_paths(state, paths, min_hops=2, path_count=200)
ping_result = ping.ping(paths=paths,
duration_ms=2000,
verbosity='verbose',
remotes=remotes)
# add data to csv file
extra = (['node_count',
'time_ms'], [node_count,
shared.millis() - test_beg_ms])
shared.csv_update(csvfile, '\t', extra, ping_result.getData())
software.clear(remotes)
network.clear(remotes)
def run(topology, path, state):
(node_count, link_count) = shared.json_count(state)
with open(f'{prefix}scalability1-{protocol}-{topology}.csv',
'a') as csvfile:
print(f'run {protocol} on {path}')
# Start routing software
software_start_ms = shared.millis()
software.start(protocol, remotes)
software_stop_ms = shared.millis()
# Let the nodes start up and discover themselves.
shared.sleep(60)
traffic_start_ms = shared.millis()
traffic_begin = traffic.traffic(remotes)
# Send <node_count> pings.
# For a good routing algorithm, the traffic per node should be constant.
paths = ping.get_random_paths(state, 2 * node_count)
paths = ping.filter_paths(state,
paths,
min_hops=2,
path_count=node_count)
ping_result = ping.ping(remotes=remotes,
paths=paths,
duration_ms=300000,
verbosity='verbose')
traffic_stop_ms = shared.millis()
traffic_end = traffic.traffic(remotes)
sysload_result = shared.sysload(remotes)
# Stop routing software
software.clear(remotes)
# Add data to csv file
extra = ([
'node_count', 'software_startup_ms', 'traffic_measurement_ms'
], [
node_count, (software_stop_ms - software_start_ms),
(traffic_stop_ms - traffic_start_ms)
])
shared.csv_update(csvfile, '\t', extra,
(traffic_end - traffic_begin).getData(),
ping_result.getData(), sysload_result)
return (100.0 * ping_result.received / ping_result.send)
def run(protocol, csvfile):
shared.seed_random(23)
node_count = 50
state = topology.create_nodes(node_count)
mobility.randomize_positions(state, xy_range=1000)
mobility.connect_range(state, max_links=150)
# create network and start routing software
network.apply(state=state, link_command=get_tc_command, remotes=remotes)
software.start(protocol)
shared.sleep(30)
for step_distance in [50, 100, 150, 200, 250, 300, 350, 400]:
print(f'{protocol}: step_distance {step_distance}')
traffic_beg = traffic.traffic(remotes)
for n in range(0, 6):
#with open(f'graph-{step_distance}-{n}.json', 'w+') as file:
# json.dump(state, file, indent=' ')
# connect nodes range
wait_beg_ms = shared.millis()
# update network representation
mobility.move_random(state, distance=step_distance)
mobility.connect_range(state, max_links=150)
# update network
network.apply(state=state, link_command=get_tc_command, remotes=remotes)
# Wait until wait seconds are over, else error
shared.wait(wait_beg_ms, 15)
paths = ping.get_random_paths(state, 2 * 400)
paths = ping.filter_paths(state, paths, min_hops=2, path_count=200)
ping_result = ping.ping(remotes=remotes, paths=paths, duration_ms=2000, verbosity='verbose')
packets_arrived_pc = 100 * (ping_result.received / ping_result.send)
traffic_end = traffic.traffic(remotes)
# add data to csv file
extra = (['node_count', 'time_ms', 'step_distance_m', 'n', 'packets_arrived_pc'], [node_count, shared.millis() - wait_beg_ms, step_distance, n, packets_arrived_pc])
shared.csv_update(csvfile, '\t', extra, (traffic_end - traffic_beg).getData(), ping_result.getData())
traffic_beg = traffic_end
software.clear(remotes)
network.clear(remotes)
def run(protocol, files, csvfile):
shared.seed_random(1234)
for path in sorted(glob.glob(files)):
state = shared.load_json(path)
(node_count, link_count) = shared.json_count(state)
print(f'run {protocol} on {path}')
network.apply(state=state,
link_command=get_tc_command,
remotes=remotes)
shared.sleep(10)
for offset in range(0, 60, 2):
tmp_ms = shared.millis()
traffic_beg = traffic.traffic(remotes)
traffic_ms = shared.millis() - tmp_ms
tmp_ms = shared.millis()
software.start(protocol)
software_ms = shared.millis() - tmp_ms
# Wait until wait seconds are over, else error
shared.sleep(offset)
paths = ping.get_random_paths(state, 2 * 200)
paths = ping.filter_paths(state, paths, min_hops=2, path_count=200)
ping_result = ping.ping(paths=paths,
duration_ms=2000,
verbosity='verbose',
remotes=remotes)
traffic_end = traffic.traffic(remotes)
sysload_result = shared.sysload(remotes)
software.clear(remotes)
# add data to csv file
extra = (['node_count', 'traffic_ms', 'software_ms', 'offset_ms'],
[node_count, traffic_ms, software_ms, offset * 1000])
shared.csv_update(csvfile, '\t', extra,
(traffic_end - traffic_beg).getData(),
ping_result.getData(), sysload_result)
network.clear(remotes)
def run(protocol, files, csvfile):
for path in sorted(glob.glob(files)):
state = shared.load_json(path)
(node_count, link_count) = shared.json_count(state)
# Limit node count to 300
if node_count > 300:
continue
print(f'run {protocol} on {path}')
network.apply(state=state,
link_command=get_tc_command,
remotes=remotes)
shared.sleep(10)
software_start_ms = shared.millis()
software.start(protocol, remotes)
software_startup_ms = shared.millis() - software_start_ms
shared.sleep(300)
start_ms = shared.millis()
traffic_beg = traffic.traffic(remotes)
paths = ping.get_random_paths(state, 2 * 200)
paths = ping.filter_paths(state, paths, min_hops=2, path_count=200)
ping_result = ping.ping(remotes=remotes,
paths=paths,
duration_ms=300000,
verbosity='verbose')
traffic_ms = shared.millis() - start_ms
traffic_end = traffic.traffic(remotes)
sysload_result = shared.sysload(remotes)
software.clear(remotes)
network.clear(remotes)
# add data to csv file
extra = (['node_count', 'traffic_ms', 'software_startup_ms'],
[node_count, traffic_ms, software_startup_ms])
shared.csv_update(csvfile, '\t', extra,
(traffic_end - traffic_beg).getData(),
ping_result.getData(), sysload_result)
def run(protocol, csvfile):
for path in sorted(glob.glob(f'../../data/grid4/*.json')):
state = shared.load_json(path)
(node_count, link_count) = shared.json_count(state)
print(f'run {protocol} on {path}')
network.apply(state=state,
link_command=get_tc_command,
remotes=remotes)
shared.sleep(10)
software_start_ms = shared.millis()
software.start(protocol, remotes)
software_startup_ms = shared.millis() - software_start_ms
shared.sleep(30)
paths = ping.get_random_paths(state, 2 * link_count)
paths = ping.filter_paths(state,
paths,
min_hops=2,
path_count=link_count)
ping_result = ping.ping(remotes=remotes,
paths=paths,
duration_ms=30000,
verbosity='verbose')
sysload_result = shared.sysload(remotes)
software.clear(remotes)
# add data to csv file
extra = (['node_count',
'software_startup_ms'], [node_count, software_startup_ms])
shared.csv_update(csvfile, '\t', extra, ping_result.getData(),
sysload_result)
network.clear(remotes)
# abort benchmark when less then 40% of the pings arrive
if ping_result.transmitted == 0 or (ping_result.received /
ping_result.transmitted) < 0.4:
break
def run(protocol, csvfile):
shared.seed_random(1377)
for path in sorted(glob.glob(f'../../data/freifunk/*.json')):
state = shared.load_json(path)
(node_count, link_count) = shared.json_count(state)
dataset_name = '{}-{:04d}'.format(os.path.basename(path)[9:-5], node_count)
# limit to what the host can handle
if node_count > 310:
continue
print(f'run {protocol} on {path}')
state = network.apply(state=state, link_command=get_tc_command, remotes=remotes)
shared.sleep(10)
software.start(protocol, remotes)
shared.sleep(300)
start_ms = shared.millis()
traffic_beg = traffic.traffic(remotes)
paths = ping.get_random_paths(state, 2 * node_count)
paths = shared.filter_paths(state, paths, min_hops=2, path_count=node_count)
ping_result = shared.ping(remotes=remotes, paths=paths, duration_ms=300000, verbosity='verbose')
sysload_result = shared.sysload(remotes)
traffic_ms = shared.millis() - start_ms
traffic_end = traffic.traffic(remotes)
software.clear(remotes)
# add data to csv file
extra = (['dataset_name', 'node_count', 'traffic_ms'], [dataset_name, node_count, traffic_ms])
shared.csv_update(csvfile, '\t', extra, (traffic_end - traffic_beg).getData(), ping_result.getData(), sysload_result)
network.clear(remotes)
def run(node_count, csvfile):
print(f'run for node_count: {node_count}')
state = topology.create_nodes(node_count)
for max_range in float_range(0.0, 0.8, 0.01):
# calculate every value 100 times
for _ in range(0, 100):
mobility.randomize_positions(state, xy_range=1.0)
mobility.connect_range(state, max_distance=max_range)
paths = get_all_paths(node_count)
(connected_path_count, connected_median_hop_count, connected_max_hop_count) = get_connectivity(state, paths)
mean_geo_distance = get_mean_geo_distance(state, paths)
# add data to csv file
connectivity_per = 100 * connected_path_count / len(paths)
extra = (
['node_count', 'max_range', 'mean_geo_distance', 'connectivity_per', 'connected_median_hop_count', 'connected_max_hop_count'],
[node_count, max_range, mean_geo_distance, connectivity_per, connected_median_hop_count, connected_max_hop_count]
)
shared.csv_update(csvfile, '\t', extra)
def run(protocol, tasks, csvfile):
for path, gateways in tasks:
state = shared.load_json(path)
(node_count, link_count) = shared.json_count(state)
# Limit node count to 300
if node_count > 300:
continue
print(f'run {protocol} on {path}')
network.apply(state=state, remotes=remotes)
shared.sleep(10)
software_start_ms = shared.millis()
software.start(protocol, remotes)
software_startup_ms = shared.millis() - software_start_ms
shared.sleep(30)
start_ms = shared.millis()
traffic_beg = traffic.traffic(remotes)
paths = ping.get_paths_to_gateways(state, gateways)
ping_result = ping.ping(remotes=remotes, paths=paths, duration_ms=300000, verbosity='verbose')
traffic_ms = shared.millis() - start_ms
traffic_end = traffic.traffic(remotes)
sysload_result = shared.sysload(remotes)
software.clear(remotes)
network.clear(remotes)
# add data to csv file
extra = (['node_count', 'traffic_ms', 'software_startup_ms'], [node_count, traffic_ms, software_startup_ms])
shared.csv_update(csvfile, '\t', extra, (traffic_end - traffic_beg).getData(), ping_result.getData(), sysload_result)