MeasurementsHelper.py

import pandas as pd
from enum import Enum

from UtilityHelper import *

class PerfMetric(Enum):
    THROUGHPUT = 'throughput (Mbps)'
    LOSS_RATIO = 'loss rate (%)'
    RETRANSMISSION_RATIO = 'retransmission (%)'
    NB_SENT_PACKETS = '# sent packets'
    DELAY = 'delay (msec)'
    ELSE = 'else'

    
########################################### Per Trace Performance ########################################## 

class Performance:
    
    def __init__(self, pkts_df, start_t, end_t, perf_func, state_func): 
        self.pkts_df = pkts_df
        self.start_t = start_t
        self.end_t = end_t
        self.perf_func = perf_func
        self.perf_cache = {}
        self.state_func = state_func
    
    def clear_cache(self):
        self.perf_cache = {}
        
    def compute_perfs(self, interval_size):
        if interval_size not in self.perf_cache:
            intervals, perfs = create_intervals_list(self.start_t, self.end_t, interval_size), []
            for interval in intervals:
                perfs.append((interval[0], self.perf_func(self.pkts_df, interval)))
            self.perf_cache[interval_size] = pd.DataFrame(perfs, columns=['time', 'perf'])
            
        return self.perf_cache[interval_size]
    
    def compute_total_perf(self):
        return self.perf_func(self.pkts_df, [self.start_t, self.end_t])
    
    def get_good_state(self, perf, threshold):
        return self.state_func(perf, threshold)
    
    def compute_good_prob(self, interval_size, threshold):
        perfs = self.compute_perfs(interval_size)
        perfs = perfs[perfs.perf != -1]
        
        good_states = perfs['perf'].apply(lambda val: self.get_good_state(val, threshold))*1
        return to_pct(np.average(good_states))
    
    
class RetransmissionPerf(Performance):
    
    def __init__(self, pkts_df, start_t, end_t):
        self.metric = PerfMetric.RETRANSMISSION_RATIO
        super().__init__(pkts_df, start_t, end_t, RetransmissionPerf.compute_retransmission_ratio, RetransmissionPerf.is_state_good)
        
    def compute_retransmission_ratio(pkts_df, interval):
        temp_df = pkts_df[pkts_df['time'].between(interval[0], interval[1])]
        if temp_df.shape[0] == 0: return -1
        return to_pct(temp_df[temp_df['is_retransmitted'] == 1]['size'].sum() / temp_df['size'].sum())
    
    def is_state_good(perf, threshold):
        return perf < threshold
        
        
class LossPerf(Performance):
    
    def __init__(self, pkts_df, start_t, end_t):
        self.metric = PerfMetric.LOSS_RATIO
        super().__init__(pkts_df, start_t, end_t, LossPerf.compute_loss_ratio, LossPerf.is_state_good)
        
    def compute_loss_ratio(pkts_df, interval):
        temp_df = pkts_df[pkts_df['time'].between(interval[0], interval[1])]
        if temp_df.shape[0] == 0: return -1
        return to_pct(temp_df[temp_df['is_lost'] == 1]['size'].sum() / temp_df['size'].sum())
    
    def is_state_good(perf, threshold):
        return perf < threshold
    
        
        
class ThroughputPerf(Performance):
    
    def __init__(self, pkts_df, start_t, end_t):
        self.metric = PerfMetric.THROUGHPUT
        super().__init__(pkts_df, start_t, end_t, ThroughputPerf.compute_xput, ThroughputPerf.is_state_good)
        
    def compute_xput(pkts_df, interval):
        temp_df = pkts_df[pkts_df['time'].between(interval[0], interval[1])]
        if temp_df.shape[0] == 0: return -1
        return round(B_to_Mb(temp_df['size'].sum()) / (interval[1]-interval[0]), 3)
    
    def is_state_good(perf, threshold):
        return perf >= threshold
    
    
    
class NbSentPacketsPerf(Performance):
    
    def __init__(self, pkts_df, start_t, end_t):
        self.metric = PerfMetric.NB_SENT_PACKETS
        super().__init__(pkts_df, start_t, end_t, NbSentPacketsPerf.compute_nb_sent_packets, (lambda perf, threshold: True))
        
    def compute_nb_sent_packets(pkts_df, interval):
        temp_df = pkts_df[pkts_df['time'].between(interval[0], interval[1])]
        return temp_df.shape[0]
    


class DelayPerf(Performance):
    
    def __init__(self, pkts_df, start_t, end_t):
        self.metric = PerfMetric.DELAY
        super().__init__(pkts_df, start_t, end_t, DelayPerf.compute_avg_delay, DelayPerf.is_state_good)
        
    def compute_avg_delay(pkts_df, interval):
        temp_df = pkts_df[pkts_df['time'].between(interval[0], interval[1])]
        return temp_df['delay'].sum() / temp_df.shape[0]
    
    def is_state_good(perf, threshold):
        return perf < threshold
    
    
########################################### Path-Pair Performance ##########################################

class PathPairPerf:
    
    def __init__(self, paths_perf):
        self.paths_perf = paths_perf
    
    def compute_perfs(self, interval_size):
        perfs = [perf.compute_perfs(interval_size) for perf in self.paths_perf]
        perfs = [df[df.perf != -1] for df in perfs]
        return pd.merge(perfs[0], perfs[1], how='inner', on=['time'], suffixes=('_p1', '_p2'))
    
    
class SelectivePathPairPerf(PathPairPerf):
    
    def __init__(self, paths_perf, filter_f=(lambda x:x)):
        super().__init__(paths_perf)
        self.filter_f = filter_f
    
    def compute_perfs(self, interval_size):
        return self.filter_f(super().compute_perfs(interval_size))


class SelectivePathPairPerfList():
    
    def __init__(self, paths_perf_list):
        self.paths_perf_list = paths_perf_list
    
    def compute_perfs(self, interval_size):
        result = pd.concat([
            paths_perf.compute_perfs(interval_size) for paths_perf in self.paths_perf_list
        ])
        return result