import numpy as np
import matplotlib.pyplot as plt

%matplotlib inline

def plot_throughput(pkt_sizes, tp_in_gbps):
    if len(pkt_sizes) != len(tp_in_gbps):
        print("number of x and y values is not the same")
        return
    plt.figure(3,figsize=(20,10))
    plt.plot(pkt_sizes, tp_in_gbps)
    plt.axis((0,1550,0,20))
    plt.xlabel('Packet size [Byte]')
    plt.ylabel('Throughput [Gbit/s]')
    plt.show()

packet_sizes = [64, 128, 256, 384, 512]
throughput_in_gbps = [1.256, 2.2259, 4.128, 6.04384, 7.91616]
plot_throughput(packet_sizes, throughput_in_gbps)

%matplotlib inline

packet_sizes_extrapolated = [
    64, 128, 256, 384, 512, 768, 1024, 1280, 1500
]
throughput_in_gbps_extrapolated = [
    1.256, 2.2259, 4.128, 6.04384, 7.91616
    # begin insert code
    
    # The throughput increases linearly until the line rate of the 10 Gbit NIC is reached
    # and stays constant afterwards.
    ,10,10,10,10
    
    # end insert code
]

plot_throughput(packet_sizes_extrapolated, throughput_in_gbps_extrapolated)

def convert_to_mpps(gbps_list, pkt_sz_list):
    result = []
    # begin insert code
    
    for g,p in zip(gbps_list, pkt_sz_list):
        # To calculate the packets per second from the data rate given, 
        # the values have to be divided by the packet size + 20 bytes 
        # including inter frame gap, preamble and start of frame delimiter.
        result.append(((g * 1000 * 1000 * 1000) / ((p + 20) * 8 )) / 1000000)
    
    # end insert code
    return result

tp_in_mpps = convert_to_mpps(throughput_in_gbps_extrapolated, packet_sizes_extrapolated)
print(tp_in_mpps)

[1.8690476190476188, 1.8799831081081082, 1.8695652173913044, 1.87, 1.86, 1.586294416243655, 1.1973180076628354, 0.9615384615384615, 0.8223684210526315]

def convert_to_cpuload(mpps_list):
    result = []

    # begin insert code
    
    # Maximum transfer rate given in problem setting,
    # as we assume 64 byte packets to cause maximum
    # CPU load
    max_rate = mpps_list[0]
    for g in mpps_list:
        # relative calculation 
        result.append(g/max_rate)
    
    # end insert code

    return result

cpuload = convert_to_cpuload(tp_in_mpps)
print(cpuload)

[1.0, 1.0058508349113446, 1.0002769315978954, 1.0005095541401277, 0.9951592356687899, 0.8487180316208092, 0.6406032652463578, 0.514453699167075, 0.4399932953402615]

%matplotlib inline

def plot_cpu_load(pkt_sizes, cpu_load):
    # begin insert code
    
    if len(pkt_sizes) == len(cpu_load):
        plt.figure(3,figsize=(20,10)) 
        plt.plot(pkt_sizes, [c * 100 for c in cpu_load])
        plt.axis((0, 1550, 0, 105))
        plt.xlabel('Packet size [Byte]')
        plt.ylabel('CPU load [%]')
        plt.show()
 
    # end insert code
    return

plot_cpu_load(packet_sizes_extrapolated, cpuload)

import numpy as np

# \mu = 5, \sigma = 0.6, and 50000 samples
distribution_data = np.random.lognormal(5, 0.6, 50000)

%matplotlib inline

import matplotlib.pyplot as plt

def plot_histogram(data):
    # begin insert code

    plt.figure(3,figsize=(20,10)) 
    plt.hist(data, bins = 1000)
    plt.xlabel("Latency [us]")
    plt.ylabel("Frequency")
    plt.xlim(0, np.percentile(data, 99.9))
    plt.show()
 
    # end insert code
    return
    
plot_histogram(distribution_data)

def calc_basic_properties(data):
    result = {
              'average': 0, 
              'std_deviation': 0,
              'median': 0,
              'percentile99': 0,
              'percentile999': 0,
             }
    
    # begin insert code

    result['average'] = np.average(data)
    result['std_deviation'] = np.std(data)
    result['median'] = np.median(data)
    result['percentile99'] = np.percentile(data, 99)
    result['percentile999'] = np.percentile(data, 99.9)

    # end insert code
    
    return result

# print results
for key, value in calc_basic_properties(distribution_data).items():
    print('{:14}: {}'.format(key, value))

average       : 176.94332058403472
std_deviation : 115.43116500740415
median        : 148.2987911689638
percentile99  : 588.4605765956042
percentile999 : 942.4409397864906

import math

# probability to have at least one noticable lag event
def probability_for_lag_event(experiment_time_in_sec):
    result = 1.0
    
    # begin insert code

    # probability for user happy event => 99.9% => 0.999

    # probability for user happy event in one second => 0.999^60
    
    # probability for user unhappy event in one second = 1 - (0.999^60)
    
    # probability for user unhappy event depending on seconds:
    
    return 1.0 - math.pow(0.999, (60*experiment_time_in_sec))

    # end insert code
    return result
    
print("Probability to see at least one lag event ( 1s): ", probability_for_lag_event(1))
print("Probability to see at least one lag event (60s): ", probability_for_lag_event(60))

Probability to see at least one lag event ( 1s):  0.0582637377768318
Probability to see at least one lag event (60s):  0.9727254487692769

%matplotlib inline

import numpy as np
import matplotlib.pyplot as plt

# Download RTT CSV from ACN website
!wget -N https://acn.net.in.tum.de/exercise/tcp_rtt.npz

# Load file into Python
data = np.load('tcp_rtt.npz')
ts, rtt = data['ts'], data['rtt']

--2025-01-31 09:51:11--  https://acn.net.in.tum.de/exercise/tcp_rtt.npz
Resolving acn.net.in.tum.de (acn.net.in.tum.de)... 2a00:4700:0:9:f::1, 188.95.232.11
Connecting to acn.net.in.tum.de (acn.net.in.tum.de)|2a00:4700:0:9:f::1|:443... connected.
HTTP request sent, awaiting response... 304 Not Modified
File ‘tcp_rtt.npz’ not modified on server. Omitting download.

# Helper function to plot data
def plot(*data, x_label=None, y_label=None, legends=[], y_min=None, y_max=None):
    plt.figure(figsize=(18, 6))
    plt.xlabel(x_label)
    plt.ylabel(y_label)
    for xs, ys in data:
        plt.plot(xs, ys)
    plt.legend(legends)
    plt.gca().set_ylim(bottom=y_min, top=y_max)


plot((ts, rtt), x_label='Time in s', y_label='RTT in ms', legends=['flow1'])

def ewma(values, alpha):
    # begin insert code
    out = []
    for sample in values:
        if len(out) == 0:
            # We just use the first sample as initial value
            new_average = sample
        else:
            new_average = out[-1] * (1 - alpha) + sample * alpha
        out.append(new_average)
    return out
    # end insert code
    return values

smoothed_rtt = ewma(rtt, 0.125)
plot((ts, rtt), (ts, smoothed_rtt), x_label='Time in s', y_label='RTT in ms', legends=['RTT', 'EWMA'])

def compute_rto(samples):
    # constants
    ALPHA = 0.125
    BETA = 0.25
    K = 4
    G = 0

    # begin insert code
    output = []
    
    # Initialize values
    # SRTT <- R
    # RTTVAR <- R/2
    # RTO <- SRTT + max (G, K*RTTVAR)
    
    r = samples[0] # first sample
            
    srtt   = r
    rttvar = r / 2
    rto    = srtt + max(G, K * rttvar)
    
    output.append(rto)
    
    # we skip the first value since it was already processed in the initialization
    for rtt in samples[1:]:

        # RTTVAR <- (1 - beta) * RTTVAR + beta * |SRTT - R'|
        # SRTT <- (1 - alpha) * SRTT + alpha * R'
        # RTO <- SRTT + max (G, K*RTTVAR)

        rttvar = (1 - BETA)  * rttvar + BETA  * abs(srtt - rtt)
        srtt   = (1 - ALPHA) * srtt   + ALPHA * rtt
        rto    = srtt + max(G, K * rttvar)
        output.append(rto)
    return output

    # end insert code
    return samples

plot((ts, rtt), (ts, compute_rto(rtt)), x_label='Time in s', y_label='RTT in ms', legends=['RTT', 'RTO'])

Tutorial 4 - Performance Measurements

Open vSwitch (3.0 credits)

Long Tails (3.5 credits)

Problem 3 Exponential Weighted Moving Average (3 credits)