first commit, from top-cars conference

Author: lucabaldesi

.gitignore

@@ -0,0 +1,4 @@
+*.pdf
+*.data
+*.pyc
+__pycache__/

README.md

@@ -0,0 +1,39 @@
+IFloodS - Information Flooding Simulator
+========================================
+
+IFloodS simulates packet/information spreading in a network.
+Currently it comes with three distribution models:
+
+* tree
+* epidemics with uniform probabilities
+* epidemics with reception-equal strategy [1] 
+
+IFloodS can be used to compare delay and age of information results following different distribution paradigms for a given set of network topologies.
+IFloodS takes as input the network topologies in the _topos/_ folder, performs the simulations and produce a CSV result file on delay reception.
+
+Usage
+=====
+To compute delays:
+```
+./ifloods.py
+```
+To preprocess age of information
+```
+./analyse_aoi.py
+```
+Data can be then plotted using the script in the _img_ folder.
+
+
+Graph dataset
+=============
+
+IFloodS uses by default topologies in the _topos/_ folder. You may use any other topologies, provided they come in __.edges__ format.
+In the vehicular_model folder there is a generative model for urban traffic networks, refer to the inner README file for further information.
+
+Reference
+=========
+If you use this software, please cite:
+
+[1] Baldesi, Luca, Leonardo Maccari, and Renato Lo Cigno. “On the Properties of Infective Flooding in Low-Duty-Cycle Networks.” In 2019 15th Annual Conference on Wireless On-Demand Network Systems and Services (WONS), 2019.
+
+[2] Baldesi, Luca, Leonardo Maccari and Renato Lo Cigno. "Keep It Fresh: Reducing the Age of Information in V2X Networks", In TOP-Cars workshop, 2019.

analyse_aoi.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+
+import pandas as pd
+
+
+def analyse_aoi(duration):
+    with open("ifloods_aoi.data", 'w') as f:
+        f.write(f"seed,node,mean_aoi,mean_peak_aoi,strategy,graph\n")
+        data = pd.read_csv("ifloods.data")
+        for name in data['name'].unique():
+            d0 = data[data['name'] == name]
+            for seed in d0['seed'].unique():
+                d1 = d0[d0['seed'] == seed]
+                for strategy in ['turbo', 'plain']:
+                    d2 = d1[d1['strategy'] == strategy]
+                    for i in d2['node'].unique():
+                        peak_aoi = []
+                        dd = d2[d2['node'] == i]
+                        u = 0  # last received pkt ts
+                        k = 0  # last update time
+                        ti =0  # time integral
+                        for index, row in dd.iterrows():
+                            ti += (row['time'] + k - 2*u)*(row['time']-k)/2
+                            peak_aoi.append(row['time']-u)
+                            u = row['last_creat_ts']
+                            k = row['time']
+                        ti += (duration + k - 2*u)*(duration-k)/2
+                        peak_aoi.append(duration-u)
+
+                        ti /= duration  # mean aoi for peer i
+                        f.write(f"{seed},{i},{ti},{sum(peak_aoi)/len(peak_aoi)},{strategy},{name}\n")
+
+
+if __name__ == "__main__":
+    analyse_aoi(100)

ifloods.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python
+
+import random
+import os
+import networkx as nx
+import numpy as nm
+import tandem_queue as tq
+import matplotlib.pyplot as plt
+import multiprocessing as mp
+
+
+def optimize(A, turbo):
+    n = A.shape[0]
+    u = nm.ravel(nm.ones((n, 1)))
+    d = nm.ravel(u.dot(A))
+    M = A.dot(nm.linalg.inv(nm.diag(d)))
+    if turbo:
+        M = nm.transpose(M)
+        t = nm.ravel(u.dot(M))
+        M = M.dot(nm.linalg.inv(nm.diag(t)))
+    else:
+        t = u
+    return (M, t)
+
+
+def random_choice(n, probs):
+    s = sum(probs)
+    choice = None
+    if s > 0:
+        for i in range(n):
+            probs[i] /= s
+        choice = nm.random.choice(range(n), 1, p=probs)[0]
+    return choice
+
+def random_dest(A, j, smart_send):
+    n = A.shape[0]
+    choice = random_choice(n, nm.ravel(A[:, j]))
+    if smart_send:
+        A[choice, j] = 0
+        A[j, choice] = 0
+    return choice
+
+
+def sending_attempt(e, f, seed):
+    propagation_time = 1./100  # 1 hundredth of time cycle
+    i, M, t, S, sched, alpha = e
+
+    dest = random_dest(M, i, False)
+    if S[dest] < S[i]:
+        # print(f"{sched.elapsed_time()}: {i} sends to {dest}")
+        sched.schedule_event(propagation_time, (-2,dest,S[i]))
+
+    sched.schedule_event(1./(alpha*t[i]), (i, M, t, S, sched, alpha))
+
+
+def spanning_tree(A, seed):
+    n = A.shape[0]
+    S1 = set([(None, seed)])
+    S2 = set([seed])
+    T = set()
+    while len(S1) > 0:
+        parent,node = S1.pop()
+        S2.remove(node)
+        for i in range(n):
+            if A[i, node] > 0:
+                if i in T or i in S2:
+                    A[i, node] = 0
+                else:
+                    S1.add((node, i))
+                    S2.add(i)
+        if parent is not None:
+            A[parent, node] = 1
+        T.add(node)
+    return optimize(A, False)
+
+
+def simulate_flooding(G, dist, f, alpha=1, duration=100, lambdy=1, seed=None, name="culo"):
+    A = nx.to_numpy_matrix(G)
+    n = A.shape[0]
+    if seed is None:
+        seed = random.sample(range(n), 1)[0]
+    if dist == "turbo":
+        M, t = optimize(A, True)
+    if dist == "plain":
+        M, t = optimize(A, False)
+    if dist == "tree":
+        M, t = spanning_tree(A, seed)
+
+    print(f"Simulating on {name}, {dist} distribution on graph with {n} nodes, seed {seed}")
+    sched = tq.EventScheduler()
+    S = {}
+
+    for i in range(n):
+        S[i] = 0  # last packet received timestamp
+        sched.schedule_event(1./(alpha*t[i]), (i, M, t, S, sched, alpha))
+
+    sched.schedule_event(lambdy, (-1,))
+
+    while sched.elapsed_time() < duration:
+        e = sched.pop_event()
+        if e[0] == -1:
+            S[seed] = sched.elapsed_time()
+            sched.schedule_event(lambdy, (-1,))
+        elif e[0] == -2:
+            if S[e[1]] < e[2]:
+                S[e[1]] = e[2]
+                f.write(f"{seed},{sched.elapsed_time()},{e[1]},{S[e[1]]},{dist},{el}\n")
+        else:
+            sending_attempt(e, f, seed)
+
+if __name__ == "__main__":
+    duration = 100
+    input_list = []
+    pool = mp.Pool(8)
+    with open("ifloods.data", "w") as f:
+        f.write("seed,time,node,last_creat_ts,strategy,name\n")
+        for folder in ["topos/"]:
+            for el in os.listdir(folder):
+                if el.endswith(".edges"):
+                    G = nx.read_weighted_edgelist(folder + el)
+                    n = len(G.nodes())
+                    for seed in range(3): # random.sample(range(n), 10):
+                        simulate_flooding(G, "turbo", f, seed=seed, duration=duration, name=el.split('.')[0])
+                        simulate_flooding(G, "plain", f, seed=seed, duration=duration, name=el.split('.')[0])

img/aoi_preproc.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+import sys
+import pandas as pd
+import numpy as nm
+
+
+def data_preproc(pivot, measure, name):
+    data = pd.read_csv("../ifloods_aoi.data")
+    # seed,node,mean_aoi,mean_peak_aoi,strategy
+    dd = data[data["graph"] == name]
+    data_p = dd[dd["strategy"] == "plain"]
+    data_t = dd[dd["strategy"] == "turbo"]
+    rows = []
+    for seed in set(dd[pivot]):
+        part = data_p[data_p[pivot] == seed][measure]
+        meanplain = part.mean()
+        minplain = part.min()
+        maxplain = part.max()
+        plain10p = nm.percentile(part, 10)
+        plain90p = nm.percentile(part, 90)
+
+        part = data_t[data_t[pivot] == seed][measure]
+        meanturbo = part.mean()
+        minturbo = part.min()
+        maxturbo = part.max()
+        turbo10p = nm.percentile(part, 10)
+        turbo90p = nm.percentile(part, 90)
+
+        rows.append({"graph": name, pivot: seed, "minplain": minplain, "10pplain": plain10p, "meanplain": meanplain, "90pplain": plain90p, "maxplain": maxplain,
+            "minturbo": minturbo, "10pturbo": turbo10p, "meanturbo": meanturbo, "90pturbo": turbo90p, "maxturbo": maxturbo})
+    f = pd.DataFrame(rows)
+    f.sort_values(by=["meanturbo"], inplace=True)
+    f = f[::2]
+
+    print(f"graph,seed,minplain,plain10p,meanplain,plain90p,maxplain,minturbo,turbo10p,meanturbo,turbo90p,maxturbo")
+    for index, row in f.iterrows():
+        print(f"{row['graph']},{row[pivot]},{row['minplain']},{row['10pplain']},{row['meanplain']},{row['90pplain']},{row['maxplain']},{row['minturbo']},{row['10pturbo']},{row['meanturbo']},{row['90pturbo']},{row['maxturbo']}")
+
+if __name__ == "__main__":
+    target = "sender"
+    measure = "mean_aoi"
+    name = "100_384_PL_0.edges"
+    if len(sys.argv) > 1:
+        target = sys.argv[1]
+    if len(sys.argv) > 2:
+        measure = sys.argv[2]
+    if len(sys.argv) > 3:
+        measure = sys.argv[3]
+
+    if target == "sender":
+        data_preproc("seed", measure, name)
+    elif target == "receiver":
+        data_preproc("node", measure, name)

img/colors.gnuplot

@@ -0,0 +1,9 @@
+C1 = "#0003ff";
+C2 = "#00bfff";
+C3 = "#4fffff";
+C4 = "#00000a";
+
+#C1 = "#ff0300";
+#C2 = "#bfff00";
+#C3 = "#4fffff";
+#C4 = "#00000a";

img/conf_interval.py

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+import sys
+import pandas as pd
+import numpy as np
+import scipy as sp
+import scipy.stats
+
+
+def mean_confidence_interval(data, confidence=0.99):
+    a = 1.0*np.array(data)
+    n = len(a)
+    m, se = np.mean(a), scipy.stats.sem(a)
+    h = se * sp.stats.t._ppf((1+confidence)/2., n-1)
+    return m, m-h, m+h
+
+
+if __name__ == "__main__":
+    data = pd.read_csv(sys.argv[1])
+    ind_var = (sys.argv[2])
+    dep_var = (sys.argv[3])
+
+    print("id,mean,leftint,rightint")
+    for iv in sorted(set(data[ind_var])):
+        part = data[data[ind_var] == iv]
+        conf = mean_confidence_interval(np.array(part[dep_var]))
+        print("{},{}".format(iv, ",".join([str(v) for v in conf])))

img/generic.gnuplot

@@ -0,0 +1,14 @@
+reset
+load 'colors.gnuplot'
+# set terminal postscript eps enhanced solid "Helvetica" 20
+set terminal pdfcairo enhanced font "Helvetica,18"
+# set terminal pdf enhanced dashed
+# set termoption linewidth 3 font "Helvetica, 14" 
+set datafile separator ","
+set lmargin 8
+set rmargin 2
+
+ptpbound(x) = real(system(sprintf("./p2p_bound.py %f", x)))
+lower_bound(x) = real(system(sprintf("./lower_bound.py %f", x)))
+upper_bound(x) = real(system(sprintf("./upper_bound.py %f", x)))
+seed_turbo_average(x) = real(system(sprintf("cat %s | python perc_interval.py /dev/stdin seed_pos turbo_time | awk -F ',' 'BEGIN{sum=0;n=0}{sum+=$2;n+=1}END{print sum/n;}'", x)))

img/ifloods_aoi.gnuplot

@@ -0,0 +1,70 @@
+load 'generic.gnuplot'
+
+bound_mean(x) = real(system(sprintf("./upper_bound.py %f", x))) + 0.5
+bound_peak(x) = real(system(sprintf("./upper_bound.py %f", x))) + 1 
+
+set termoption lw 3
+set boxwidth 0.1 
+
+set style fill solid
+
+set key over
+set xrange[0.5:3.5]
+
+set ylabel "{/Symbol @^{/=35-}D} (cycles)" font ", 18" offset 1.0,0
+set xlabel "Graph ID"
+
+set xtics (1,2,3)
+set output 'ifloods_mean_aoi.pdf'
+plot "< cat ../ifloods_aoi.data |awk '/strategy|plain/{print}' | python perc_interval.py /dev/stdin graph mean_aoi"\
+	using ($0-0.15):3:2:6:5  lc rgb C3 with candlesticks title '{/Symbol @^{/=35-}D}, SE_f' whiskerbars,\
+	"< cat ../ifloods_aoi.data |awk '/strategy|turbo/{print}' | python perc_interval.py /dev/stdin graph mean_aoi"\
+	using ($0+0.15):3:2:6:5  lc rgb C4 with candlesticks title '{/Symbol @^{/=35-}D}, RE_f' whiskerbars,\
+	bound_mean(x) with lines lc rgb C1 title "{/Symbol g}"
+
+unset xtics
+set xtics 
+set terminal pdfcairo enhanced font "Helvetica,10" size 5,1.5
+
+set lmargin 3
+set rmargin 1
+
+set tics scale 0
+
+set xrange[0:51]
+set termoption lw 1
+set boxwidth 0.25
+
+set style fill solid
+unset ylabel
+ 
+#set ylabel "Mean AoI (cycles)" font ", 12" offset 1.0,0
+set xlabel "Sender"
+set output 'ifloods_mean_aoi_senders.pdf'
+plot "< python3 aoi_preproc.py sender mean_aoi"\
+	using ($0-0.25):4:3:7:6 lc rgb C3 with candlesticks title '{/Symbol @^{/=20-}D}, SE_f' whiskerbars,\
+	"" using ($0+0.25):9:8:12:11 lc rgb C4 with candlesticks title '{/Symbol @^{/=20-}D}, RE_f' whiskerbars,\
+	bound_mean(100) with lines lc rgb C1 title "{/Symbol g} "
+
+set xlabel "Receiver"
+set output 'ifloods_mean_aoi_receivers.pdf'
+plot "< python3 aoi_preproc.py receiver mean_aoi"\
+	using ($0-0.25):4:3:7:6 lc rgb C3 with candlesticks title '{/Symbol @^{/=20-}D}, SE_f' whiskerbars,\
+	"" using ($0+0.25):9:8:12:11 lc rgb C4 with candlesticks title '{/Symbol @^{/=20-}D}, RE_f' whiskerbars,\
+	bound_mean(100) with lines lc rgb C1 title "{/Symbol g}"
+
+#set ylabel "Mean Peak AoI (cycles)" font ", 12" offset 1.0,0
+
+set xlabel "Sender"
+set output 'ifloods_mean_peak_aoi_senders.pdf'
+plot "< python3 aoi_preproc.py sender mean_peak_aoi"\
+	using ($0-0.25):4:3:7:6 lc rgb C2 with candlesticks title 'Mean peak AoI, plain' whiskerbars,\
+	"" using ($0+0.25):9:8:12:11 lc rgb C1 with candlesticks title 'Mean peak AoI, turbo' whiskerbars,\
+	bound_peak(100) with lines lc rgb C4 title "AoI stochastic bound"
+
+set xlabel "Receiver"
+set output 'ifloods_mean_peak_aoi_receivers.pdf'
+plot "< python3 aoi_preproc.py receiver mean_peak_aoi"\
+	using ($0-0.25):4:3:7:6 lc rgb C2 with candlesticks title 'Mean peak AoI, plain' whiskerbars,\
+	"" using ($0+0.25):9:8:12:11 lc rgb C1 with candlesticks title 'Mean peak AoI, turbo' whiskerbars,\
+	bound_peak(100) with lines lc rgb C4 title "AoI stochastic bound"