def main():
#Parse input values
parser = argparse.ArgumentParser()
parser.add_argument('XI', type=float)
parser.add_argument('PSI', type=float)
parser.add_argument('DEST')
parser.add_argument('TESTNO')
parser.add_argument('--on', action='store_true')
#parser.add_argument('RTT', type=float)
args = parser.parse_args()
XI = args.XI
PSI = args.PSI
dest = args.DEST
add = args.TESTNO
on = args.on
#nominalrtt = args.RTT
#Initialize values
intervalNum = 0
rate, controllerRate = -1, -1
oldrtt = -1
flowFound = False
controller = Controller(PSI, XI, GAMMA, P, Q, ALPHA)
#Set qdisc
subprocess.check_call(['tc', 'qdisc', 'add', 'dev', 'eth4', 'root', 'fq'])
#Start bwctl
subprocess.Popen([
'bwctl', '-c', dest, '-T', 'iperf3', '-i.1', '-w150m', '-t60',
'--parsable', '-p'
])
#Initialize bytes for throughput count
oldBytes = getBytes()
#Initialize timedelta
startTime = datetime.now()
with tempfile.NamedTemporaryFile(suffix='.csv', delete=False) as output:
writer = csv.writer(output)
writer.writerow([
'end', 'ertt', 'lHat', 'samplertt', 'controlRate', 'throughput',
'retransmits', 'cwnd', 'mss', 'txPort', 'rxPort'
])
for i in range(30000):
time.sleep(.01)
#Get throughput every 100ms
if i % 10 == 0:
newBytes = getBytes()
tput = ((newBytes - oldBytes) * 8) / float(1000)
#Get flow stats every 10ms
ssout = pollss()
ips, ports, rtt, wscaleavg, cwnd, retrans, mss = findconn(
ssout, dest)
#When the flow is actually occurring
if rtt != -1:
flowFound = True
#Inversion of RTT to sample RTT
#First time seeing this flow
if oldrtt == -1:
oldrtt = rtt
startTime = datetime.now()
#elif nominalrtt<0 or rtt<nominalrtt: #stopped finding the lowest RTT
# nominalrtt = rtt
delta = rtt - oldrtt
samplertt = oldrtt + (delta * 8)
#if samplertt < nominalrtt:
#samplertt = nominalrtt
#print('samplertt was less than nominal')
#if nominalrtt > 0:
# samplertt = nominalrtt
#else:
# samplertt = 1
#Code for calling controller
rate, lHat = controller.Process(rtt)
if on:
setfq(rate)
end = startTime - datetime.now()
writer.writerow([
end, rtt, lHat, samplertt, rate, tput, retrans, cwnd, mss,
ports[0], ports[1]
])
elif flowFound:
break
oldrtt = rtt
oldBytes = newBytes
controlStat = 'off'
if on:
controlStat = 'on'
#Write out the temporary controller logic file
shutil.copy2(
output.name, 'XI-' + str(XI) + '-PSI-' + str(PSI) + '-' + dest + '-' +
add + '-' + controlStat + '-controlOutput.csv')
os.unlink(output.name)
#Wait 10 seconds for bwctl output
time.sleep(45)
#Convert the bwctl json file to csv
for basename in os.listdir('.'):
if basename.endswith('.bw'):
with open(basename) as fp:
data = json.load(fp)
newpath = 'XI-' + str(XI) + '-PSI-' + str(
PSI
) + '-' + dest + '-' + add + '-' + controlStat + '-iPerfOutput.csv'
with open(newpath, 'wb') as ofp:
writer = csv.writer(ofp)
title = data['intervals'][0]['streams'][0].keys()
if 'omitted' in title: title.remove('omitted')
writer.writerow(title)
for interval in data['intervals']:
del interval['streams'][0]['omitted']
vals = interval['streams'][0].values()
writer.writerow(vals)
#Delete qdisc
subprocess.check_call(['tc', 'qdisc', 'del', 'dev', 'eth4', 'root'])
sys.exit()
world = LatencyGenerator(L_MAX, L_SLOPE, L_CUT, R_COEFF, NOISE_SD)
# Create a controller.
controller = Controller(PSI, XI, GAMMA, P, Q, ALPHA)
# Run.
recorded_index = np.arange(NUM_DATA_POINTS)
recorded_latency = np.zeros(NUM_DATA_POINTS)
predicted_latency = np.zeros(NUM_DATA_POINTS)
recorded_control = np.zeros(NUM_DATA_POINTS)
recorded_mu = np.zeros(NUM_DATA_POINTS)
last_control = 0.0
for ii in range(NUM_DATA_POINTS):
predicted_latency[ii] = controller.model_.Predict(last_control, True)
recorded_latency[ii] = world.Generate(last_control)
last_control = max(0.0, controller.Process(recorded_latency[ii])[0])
recorded_control[ii] = last_control
# Plot.
plt.figure()
plt.plot(recorded_index, recorded_latency, 'r--',
recorded_index, predicted_latency, 'g^',
recorded_index, recorded_control, 'bs')
plt.legend(['Actual Latency', 'Predicted Latency', 'Control'])
plt.title('Simulation of Latency and Control')
plt.xlabel('Time step')
plt.ylabel('Arbitrary units')
plt.show()
for trial in TRIALS:
filename = DATA_PATH + "random_control.csv" #"fqOn" + str(trial) + "t.csv"
data = np.loadtxt(filename, delimiter=",", skiprows=1)
# time = data[:, TIME_COL]
time = np.arange(len(data))
rtt = data[:, RTT_COL]
control = data[:, CONTROL_COL]
# Run filter.
predicted_latency = np.zeros(len(rtt))
predicted_control = np.zeros(len(rtt))
for ii in range(len(rtt)):
l_hat = model.Predict(float(control[ii]))
predicted_latency[ii] = max(0.0, l_hat)
model.Update(rtt[ii], l_hat)
r_opt = controller.Process(rtt[ii])
predicted_control[ii] = r_opt
# Plot.
plt.figure()
plt.plot(time, rtt, 'r--o', time, predicted_latency, 'g:*', time,
predicted_control, 'b:^')
plt.legend(['Actual Latency', 'Predicted Latency', 'Predicted Control'])
#plt.title("Filter Performance for Trial " + str(trial));
plt.title("Filter Performance for Random Control")
plt.xlabel('Time (s)')
plt.ylabel('Round trip time (us)')
plt.show()
