diff options
| -rwxr-xr-x | VNFs/DPPD-PROX/helper-scripts/rapid/runrapid.py | 279 |
1 files changed, 162 insertions, 117 deletions
diff --git a/VNFs/DPPD-PROX/helper-scripts/rapid/runrapid.py b/VNFs/DPPD-PROX/helper-scripts/rapid/runrapid.py index 5e408906..0e235959 100755 --- a/VNFs/DPPD-PROX/helper-scripts/rapid/runrapid.py +++ b/VNFs/DPPD-PROX/helper-scripts/rapid/runrapid.py @@ -34,8 +34,8 @@ import ast import atexit import csv import requests -from numpy import inf from math import ceil +inf = float("inf") version="20.01.10" env = "rapid.env" #Default string for environment @@ -121,6 +121,7 @@ class bcolors: ENDC = '\033[0m' BOLD = '\033[1m' UNDERLINE = '\033[4m' + FLASH = '\033[5m' # create formatters screen_formatter = logging.Formatter("%(message)s") @@ -300,13 +301,12 @@ def run_iteration(gensock, sutsock, requested_duration,flow_number,size,speed): tot_sut_core_measurement_duration = float(0) tot_sut_rx = tot_sut_non_dp_rx = tot_sut_tx = tot_sut_non_dp_tx = tot_sut_drop = tot_sut_tx_fail = tot_sut_tsc = 0 lat_avail = core_avail = sut_avail = False - ##while (tot_core_measurement_duration - float(requested_duration) <= 0.1) or (tot_sut_core_measurement_duration - float(requested_duration) <= 0.1) or (tot_lat_measurement_duration - float(requested_duration) <= 0.1): while (tot_core_measurement_duration - float(requested_duration) <= 0.1) or (tot_lat_measurement_duration - float(requested_duration) <= 0.1): time.sleep(0.5) lat_min_sample, lat_max_sample, lat_avg_sample, used_sample, t3_lat_tsc, lat_hz, buckets = gensock.lat_stats(latcores) - single_lat_measurement_duration = (t3_lat_tsc - t2_lat_tsc) * 1.0 / lat_hz # time difference between the 2 measurements, expressed in seconds. # Get statistics after some execution time - if single_lat_measurement_duration != 0: + if t3_lat_tsc != t2_lat_tsc: + single_lat_measurement_duration = (t3_lat_tsc - t2_lat_tsc) * 1.0 / lat_hz # time difference between the 2 measurements, expressed in seconds. # A second has passed in between to lat_stats requests. Hence we need to process the results tot_lat_measurement_duration = tot_lat_measurement_duration + single_lat_measurement_duration if lat_min > lat_min_sample: @@ -331,9 +331,8 @@ def run_iteration(gensock, sutsock, requested_duration,flow_number,size,speed): t2_lat_tsc = t3_lat_tsc lat_avail = True t3_rx, t3_non_dp_rx, t3_tx, t3_non_dp_tx, t3_drop, t3_tx_fail, t3_tsc, tsc_hz = gensock.core_stats(genstatcores,gentasks) - single_core_measurement_duration = (t3_tsc - t2_tsc) * 1.0 / tsc_hz # time difference between the 2 measurements, expressed in seconds. - if single_core_measurement_duration!= 0: - stored_single_core_measurement_duration = single_core_measurement_duration + if t3_tsc != t2_tsc: + single_core_measurement_duration = (t3_tsc - t2_tsc) * 1.0 / tsc_hz # time difference between the 2 measurements, expressed in seconds. tot_core_measurement_duration = tot_core_measurement_duration + single_core_measurement_duration delta_rx = t3_rx - t2_rx tot_rx += delta_rx @@ -353,9 +352,8 @@ def run_iteration(gensock, sutsock, requested_duration,flow_number,size,speed): core_avail = True if sutsock!='none': t3_sut_rx, t3_sut_non_dp_rx, t3_sut_tx, t3_sut_non_dp_tx, t3_sut_drop, t3_sut_tx_fail, t3_sut_tsc, sut_tsc_hz = sutsock.core_stats(sutstatcores,tasks) - single_sut_core_measurement_duration = (t3_sut_tsc - t2_sut_tsc) * 1.0 / tsc_hz # time difference between the 2 measurements, expressed in seconds. - if single_sut_core_measurement_duration!= 0: - stored_single_sut_core_measurement_duration = single_sut_core_measurement_duration + if t3_sut_tsc != t2_sut_tsc: + single_sut_core_measurement_duration = (t3_sut_tsc - t2_sut_tsc) * 1.0 / tsc_hz # time difference between the 2 measurements, expressed in seconds. tot_sut_core_measurement_duration = tot_sut_core_measurement_duration + single_sut_core_measurement_duration tot_sut_rx += t3_sut_rx - t2_sut_rx tot_sut_non_dp_rx += t3_sut_non_dp_rx - t2_sut_non_dp_rx @@ -368,15 +366,15 @@ def run_iteration(gensock, sutsock, requested_duration,flow_number,size,speed): if test == 'fixed_rate': if lat_avail == core_avail == True: lat_avail = core_avail = False - pps_req_tx = (delta_tx + delta_drop - delta_rx)/stored_single_core_measurement_duration/1000000 - pps_tx = delta_tx/stored_single_core_measurement_duration/1000000 + pps_req_tx = (delta_tx + delta_drop - delta_rx)/single_core_measurement_duration/1000000 + pps_tx = delta_tx/single_core_measurement_duration/1000000 if sutsock!='none' and sut_avail: - pps_sut_tx = delta_sut_tx/stored_single_sut_core_measurement_duration/1000000 + pps_sut_tx = delta_sut_tx/single_sut_core_measurement_duration/1000000 sut_avail = False else: pps_sut_tx = None - pps_rx = delta_rx/stored_single_core_measurement_duration/1000000 - log.info(report_result(flow_number,size,speed,pps_req_tx,pps_tx,pps_sut_tx,pps_rx,lat_avg_sample,sample_percentile,percentile_max,lat_max_sample,delta_dp_tx,delta_dp_rx,tot_dp_drop,stored_single_core_measurement_duration)) + pps_rx = delta_rx/single_core_measurement_duration/1000000 + log.info(report_result(flow_number,size,speed,pps_req_tx,pps_tx,pps_sut_tx,pps_rx,lat_avg_sample,sample_percentile,percentile_max,lat_max_sample,delta_dp_tx,delta_dp_rx,tot_dp_drop,single_core_measurement_duration)) #Stop generating gensock.stop(gencores) r += 1 @@ -456,7 +454,7 @@ def new_speed(speed,size,success): else: TST009_R = max(TST009_m - 1, TST009_L) TST009_m = int ((TST009_L + TST009_R)/2) - return (get_percentageof10Gbs(TST009_S[TST009_m],size)) + return (get_percentageof10Gbps(TST009_S[TST009_m],size)) else: global minspeed global maxspeed @@ -476,7 +474,7 @@ def get_start_speed_and_init(size): TST009_L = 0 TST009_R = TST009_n - 1 TST009_m = int((TST009_L + TST009_R) / 2) - return (get_percentageof10Gbs(TST009_S[TST009_m],size)) + return (get_percentageof10Gbps(TST009_S[TST009_m],size)) else: global minspeed global maxspeed @@ -492,7 +490,7 @@ def resolution_achieved(): else: return ((maxspeed - minspeed) <= ACCURACY) -def get_percentageof10Gbs(pps_speed,size): +def get_percentageof10Gbps(pps_speed,size): # speed is given in pps, returning % of 10Gb/s return (pps_speed / 1000000.0 * 0.08 * (size+24)) @@ -504,6 +502,23 @@ def get_speed(packet_speed,size): # return speed in Gb/s return (packet_speed / 1000.0 * (8*(size+24))) +def set_background_flows(source_port,destination_port): + for sock in background_gen_socks: + sock.set_random(gencores,0,34,source_port,2) + sock.set_random(gencores,0,36,destination_port,2) + +def set_background_speed(speed): + for sock in background_gen_socks: + sock.speed(speed / len(gencores) / len (gentasks), gencores, gentasks) + +def start_background_traffic(): + for sock in background_gen_socks: + sock.start(gencores+latcores) + +def stop_background_traffic(): + for sock in background_gen_socks: + sock.stop(gencores+latcores) + def run_flow_size_test(gensock,sutsock): global fieldnames global writer @@ -517,11 +532,15 @@ def run_flow_size_test(gensock,sutsock): gensock.set_size(gencores,0,size) # This is setting the frame size gensock.set_value(gencores,0,16,(size-14),2) # 18 is the difference between the frame size and IP size = size of (MAC addresses, ethertype and FCS) gensock.set_value(gencores,0,38,(size-34),2) # 38 is the difference between the frame size and UDP size = 18 + size of IP header (=20) - # This will only work when using sending UDP packets. For different protocls and ethernet types, we would need a different calculation + # This will only work when using sending UDP packets. For different protocols and ethernet types, we would need a different calculation + if background_gen_socks: + backgroundinfo = '{}Running {} x background traffic not represented in the table{}'.format(bcolors.FLASH,len(background_gen_socks),bcolors.ENDC) + else: + backgroundinfo = '{}{}'.format(bcolors.FLASH,bcolors.ENDC) log.info("+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+") - log.info("| UDP, "+ '{:>5}'.format(size+4) +" bytes, different number of flows by randomizing SRC & DST UDP port |") + log.info('| UDP, {:>5} bytes, different number of flows by randomizing SRC & DST UDP port. {:116.116}|'.format((size+4),backgroundinfo)) log.info("+--------+------------------+-------------+-------------+-------------+------------------------+----------+----------+----------+-----------+-----------+-----------+-----------+-------+----+") - log.info("| Flows | Speed requested | Gen by core | Sent by NIC | Fwrd by SUT | Rec. by core | Avg. Lat.|" + '{:.0f} '.format(LAT_PERCENTILE*100) +"Pcentil| Max. Lat.| Sent | Received | Lost | Total Lost|L.Ratio|Time|") + log.info('| Flows | Speed requested | Gen by core | Sent by NIC | Fwrd by SUT | Rec. by core | Avg. Lat.|{:.0f} Pcentil| Max. Lat.| Sent | Received | Lost | Total Lost|L.Ratio|Time|'.format(LAT_PERCENTILE*100)) log.info("+--------+------------------+-------------+-------------+-------------+------------------------+----------+----------+----------+-----------+-----------+-----------+-----------+-------+----+") for flow_number in flow_size_list: attempts = 0 @@ -531,6 +550,7 @@ def run_flow_size_test(gensock,sutsock): source_port,destination_port = flows[flow_number] gensock.set_random(gencores,0,34,source_port,2) gensock.set_random(gencores,0,36,destination_port,2) + set_background_flows(source_port,destination_port) endspeed = None speed = get_start_speed_and_init(size) while True: @@ -540,15 +560,18 @@ def run_flow_size_test(gensock,sutsock): sys.stdout.flush() # Start generating packets at requested speed (in % of a 10Gb/s link) gensock.speed(speed / len(gencores) / len (gentasks), gencores, gentasks) + set_background_speed(speed) + start_background_traffic() ##time.sleep(1) # Get statistics now that the generation is stable and initial ARP messages are dealt with pps_req_tx,pps_tx,pps_sut_tx,pps_rx,lat_avg,lat_perc , lat_perc_max, lat_max, abs_tx,abs_rx,abs_dropped, abs_tx_fail, drop_rate, lat_min, lat_used, r, actual_duration = run_iteration(gensock,sutsock,float(runtime),flow_number,size,speed) + stop_background_traffic() if r > 1: retry_warning = bcolors.WARNING + ' {:1} retries needed'.format(r) + bcolors.ENDC else: retry_warning = '' # Drop rate is expressed in percentage. lat_used is a ratio (0 to 1). The sum of these 2 should be 100%. - # If the some is lower than 95, it means that more than 5% of the latency measurements where dropped for accuracy reasons. + # If the sum is lower than 95, it means that more than 5% of the latency measurements where dropped for accuracy reasons. if (drop_rate + lat_used * 100) < 95: lat_warning = bcolors.WARNING + ' Latency accuracy issue?: {:>3.0f}%'.format(lat_used*100) + bcolors.ENDC else: @@ -574,12 +597,7 @@ def run_flow_size_test(gensock,sutsock): # The following if statement is testing if we pass the success criteria of a certain drop rate, average latency and maximum latency below the threshold # The drop rate success can be achieved in 2 ways: either the drop rate is below a treshold, either we want that no packet has been lost during the test # This can be specified by putting 0 in the .test file - elif ((drop_rate < DROP_RATE_TRESHOLD) or (abs_dropped==DROP_RATE_TRESHOLD ==0)) and (lat_avg< LAT_AVG_TRESHOLD) and (lat_perc< LAT_PERC_TRESHOLD) and (lat_max < LAT_MAX_TRESHOLD): - lat_avg_prefix = bcolors.ENDC - lat_perc_prefix = bcolors.ENDC - lat_max_prefix = bcolors.ENDC - abs_drop_rate_prefix = bcolors.ENDC - drop_rate_prefix = bcolors.ENDC + elif ((drop_rate < DROP_RATE_TRESHOLD) or (abs_dropped==DROP_RATE_TRESHOLD==0)) and (lat_avg< LAT_AVG_TRESHOLD) and (lat_perc< LAT_PERC_TRESHOLD) and (lat_max < LAT_MAX_TRESHOLD): if ((get_pps(speed,size) - pps_tx)/get_pps(speed,size))>0.01: speed_prefix = bcolors.WARNING if abs_tx_fail > 0: @@ -641,6 +659,7 @@ def run_flow_size_test(gensock,sutsock): if resolution_achieved(): break if endspeed != None: + speed_prefix = lat_avg_prefix = lat_perc_prefix = lat_max_prefix = abs_drop_rate_prefix = drop_rate_prefix = bcolors.ENDC log.info(report_result(flow_number,size,endspeed,endpps_req_tx,endpps_tx,endpps_sut_tx,endpps_rx,endlat_avg,endlat_perc,endlat_perc_max,endlat_max,endabs_tx,endabs_rx,endabs_dropped,actual_duration,speed_prefix,lat_avg_prefix,lat_perc_prefix,lat_max_prefix,abs_drop_rate_prefix,drop_rate_prefix)) if endwarning: log.info (endwarning) @@ -858,6 +877,89 @@ def run_warmuptest(gensock): gensock.set_value(gencores,0,56,50,1) time.sleep(WARMUPTIME) +def exit_handler(): + log.debug ('exit cleanup') + for index, sock in enumerate(socks): + if socks_control[index]: + sock.quit() + for client in clients: + client.close() + data_csv_file.close + sys.exit(0) + +def get_BinarySearchParams() : + global DROP_RATE_TRESHOLD + global LAT_AVG_TRESHOLD + global LAT_PERC_TRESHOLD + global LAT_MAX_TRESHOLD + global ACCURACY + global STARTSPEED + global TST009 + global TST009_MAXr + global TST009_MAXz + DROP_RATE_TRESHOLD = float(testconfig.get('BinarySearchParams', 'drop_rate_threshold')) + LAT_AVG_TRESHOLD = float(testconfig.get('BinarySearchParams', 'lat_avg_threshold')) + LAT_PERC_TRESHOLD = float(testconfig.get('BinarySearchParams', 'lat_perc_threshold')) + LAT_MAX_TRESHOLD = float(testconfig.get('BinarySearchParams', 'lat_max_threshold')) + ACCURACY = float(testconfig.get('BinarySearchParams', 'accuracy')) + STARTSPEED = float(testconfig.get('BinarySearchParams', 'startspeed')) + TST009_MAXr = 1 + TST009_MAXz = inf + TST009 = False + +def get_FixedRateParams() : + global DROP_RATE_TRESHOLD + global LAT_AVG_TRESHOLD + global LAT_PERC_TRESHOLD + global LAT_MAX_TRESHOLD + global flow_size_list + global packet_size_list + global STARTSPEED + global TST009 + global TST009_MAXr + global TST009_MAXz + DROP_RATE_TRESHOLD = inf + LAT_AVG_TRESHOLD = inf + LAT_PERC_TRESHOLD = inf + LAT_MAX_TRESHOLD = inf + TST009_MAXr = 1 + TST009_MAXz = inf + TST009 = False + packet_size_list = ast.literal_eval(testconfig.get('test%d'%test_nr, 'packetsizes')) + flow_size_list = ast.literal_eval(testconfig.get('test%d'%test_nr, 'flows')) + STARTSPEED = float(testconfig.get('test%d'%test_nr, 'speed')) + +def get_TST009SearchParams() : + global DROP_RATE_TRESHOLD + global LAT_AVG_TRESHOLD + global LAT_PERC_TRESHOLD + global LAT_MAX_TRESHOLD + global TST009 + global TST009_MAXr + global TST009_MAXz + global TST009_MAXFramesAllIngress + global TST009_StepSize + global TST009_n + global TST009_L + global TST009_R + global TST009_S + if testconfig.has_option('TST009SearchParams', 'drop_rate_threshold'): + DROP_RATE_TRESHOLD = float(testconfig.get('TST009SearchParams', 'drop_rate_threshold')) + else: + DROP_RATE_TRESHOLD = 0 + LAT_AVG_TRESHOLD = inf + LAT_PERC_TRESHOLD = inf + LAT_MAX_TRESHOLD = inf + TST009_MAXr = float(testconfig.get('TST009SearchParams', 'MAXr')) + TST009_MAXz = float(testconfig.get('TST009SearchParams', 'MAXz')) + TST009_MAXFramesAllIngress = int(testconfig.get('TST009SearchParams', 'MAXFramesPerSecondAllIngress')) + TST009_StepSize = int(testconfig.get('TST009SearchParams', 'StepSize')) + TST009_n = int(ceil(TST009_MAXFramesAllIngress / TST009_StepSize)) + TST009 = True + TST009_L = 0 + TST009_R = TST009_n - 1 + for m in range(0, TST009_n): + TST009_S.append((m+1) * TST009_StepSize) # To generate a desired number of flows, PROX will randomize the bits in source and destination ports, as specified by the bit masks in the flows variable. flows={\ 1: ['1000000000000000','1000000000000000'],\ @@ -894,6 +996,8 @@ prox_launch_exit =[] auto_start =[] mach_type =[] sock_type =[] +monitor =[] +sock_monitor =[] cores = [] ports = [] tasks = {} @@ -958,6 +1062,10 @@ for vm in range(1, int(required_number_of_test_machines)+1): f.write('ports="%s"\n'% ','.join(map(str, ports[-1]))) else: ports.append(None) + if testconfig.has_option('TestM%d'%vm, 'monitor'): + monitor.append(testconfig.getboolean('TestM%d'%vm, 'monitor')) + else: + monitor.append(True) if re.match('(l2){0,1}gen(_bare){0,1}.*\.cfg',config_file[-1]): gencores = ast.literal_eval(testconfig.get('TestM%d'%vm, 'gencores')) latcores = ast.literal_eval(testconfig.get('TestM%d'%vm, 'latcores')) @@ -1033,18 +1141,6 @@ for vm in range(1, int(required_number_of_test_machines)+1): tasks = tasks_for_this_cfg.union(tasks) log.debug("Tasks detected in all PROX config files %r"%tasks) ##################################################################################### -def exit_handler(): - log.debug ('exit cleanup') - for index, sock in enumerate(socks): - if socks_control[index]: - sock.quit() - for client in clients: - client.close() - data_csv_file.close - sys.exit(0) - -atexit.register(exit_handler) - for vm in range(0, int(required_number_of_test_machines)): if prox_socket[vm]: clients.append(prox_ctrl(vmAdminIP[machine_index[vm]], key,user)) @@ -1089,89 +1185,37 @@ for vm in range(0, int(required_number_of_test_machines)): socks_control.append(prox_launch_exit[vm]) socks.append(connect_socket(clients[-1])) sock_type.append(mach_type[vm]) - -def get_BinarySearchParams() : - global DROP_RATE_TRESHOLD - global LAT_AVG_TRESHOLD - global LAT_PERC_TRESHOLD - global LAT_MAX_TRESHOLD - global ACCURACY - global STARTSPEED - global TST009 - global TST009_MAXr - global TST009_MAXz - DROP_RATE_TRESHOLD = float(testconfig.get('BinarySearchParams', 'drop_rate_threshold')) - LAT_AVG_TRESHOLD = float(testconfig.get('BinarySearchParams', 'lat_avg_threshold')) - LAT_PERC_TRESHOLD = float(testconfig.get('BinarySearchParams', 'lat_perc_threshold')) - LAT_MAX_TRESHOLD = float(testconfig.get('BinarySearchParams', 'lat_max_threshold')) - ACCURACY = float(testconfig.get('BinarySearchParams', 'accuracy')) - STARTSPEED = float(testconfig.get('BinarySearchParams', 'startspeed')) - TST009_MAXr = 1 - TST009_MAXz = inf - TST009 = False - -def get_FixedRateParams() : - global DROP_RATE_TRESHOLD - global LAT_AVG_TRESHOLD - global LAT_PERC_TRESHOLD - global LAT_MAX_TRESHOLD - global flow_size_list - global packet_size_list - global STARTSPEED - global TST009 - global TST009_MAXr - global TST009_MAXz - DROP_RATE_TRESHOLD = inf - LAT_AVG_TRESHOLD = inf - LAT_PERC_TRESHOLD = inf - LAT_MAX_TRESHOLD = inf - TST009_MAXr = 1 - TST009_MAXz = inf - TST009 = False - packet_size_list = ast.literal_eval(testconfig.get('test%d'%test_nr, 'packetsizes')) - flow_size_list = ast.literal_eval(testconfig.get('test%d'%test_nr, 'flows')) - STARTSPEED = float(testconfig.get('test%d'%test_nr, 'speed')) - -def get_TST009SearchParams() : - global DROP_RATE_TRESHOLD - global LAT_AVG_TRESHOLD - global LAT_PERC_TRESHOLD - global LAT_MAX_TRESHOLD - global TST009 - global TST009_MAXr - global TST009_MAXz - global TST009_MAXFramesAllIngress - global TST009_StepSize - global TST009_n - global TST009_L - global TST009_R - global TST009_S - if testconfig.has_option('TST009SearchParams', 'drop_rate_threshold'): - DROP_RATE_TRESHOLD = float(testconfig.get('TST009SearchParams', 'drop_rate_threshold')) - else: - DROP_RATE_TRESHOLD = 0 - LAT_AVG_TRESHOLD = inf - LAT_PERC_TRESHOLD = inf - LAT_MAX_TRESHOLD = inf - TST009_MAXr = float(testconfig.get('TST009SearchParams', 'MAXr')) - TST009_MAXz = float(testconfig.get('TST009SearchParams', 'MAXz')) - TST009_MAXFramesAllIngress = int(testconfig.get('TST009SearchParams', 'MAXFramesPerSecondAllIngress')) - TST009_StepSize = int(testconfig.get('TST009SearchParams', 'StepSize')) - TST009_n = int(ceil(TST009_MAXFramesAllIngress / TST009_StepSize)) - TST009 = True - TST009_L = 0 - TST009_R = TST009_n - 1 - for m in range(0, TST009_n): - TST009_S.append((m+1) * TST009_StepSize) - + sock_monitor.append(monitor[vm]) +atexit.register(exit_handler) +monitor_gen = monitor_sut = False +background_gen_socks =[] +for index, sock in enumerate(socks, start=0): + if sock_type[index] == 'gen': + if sock_monitor[index]: + if monitor_gen: + log.exception("Can only monitor 1 generator") + raise Exception("Can only monitor 1 generator") + else: + monitor_gen = True + gensock_index = index + else: + background_gen_socks.append(sock) + elif sock_type[index] == 'sut' and sock_monitor[index]: + if monitor_sut: + log.exception("Can only monitor 1 sut") + raise Exception("Can only monitor 1 sut") + else: + monitor_sut = True + sutsock_index = index +if not(monitor_gen and monitor_sut): + log.exception("No generator and/or sut to monitor") + raise Exception("No generator and/or sut to monitor") if configonly: sys.exit() #################################################### # Run test cases # Best to run the flow test at the end since otherwise the tests coming after might be influenced by the big number of entries in the switch flow tables #################################################### -gensock_index = sock_type.index('gen') if 'gen' in sock_type else -1 -sutsock_index = sock_type.index('sut') if 'sut' in sock_type else -1 number_of_tests = testconfig.get('DEFAULT', 'number_of_tests') for test_nr in range(1, int(number_of_tests)+1): test=testconfig.get('test%d'%test_nr,'test') @@ -1182,6 +1226,7 @@ for test_nr in range(1, int(number_of_tests)+1): flow_size_list = ast.literal_eval(testconfig.get('test%d'%test_nr, 'flows')) run_flow_size_test(socks[gensock_index],socks[sutsock_index]) elif test == 'TST009test': + # This test implements some of the testing as defined in https://docbox.etsi.org/ISG/NFV/open/Publications_pdf/Specs-Reports/NFV-TST%20009v3.2.1%20-%20GS%20-%20NFVI_Benchmarks.pdf get_TST009SearchParams() packet_size_list = ast.literal_eval(testconfig.get('test%d'%test_nr, 'packetsizes')) flow_size_list = ast.literal_eval(testconfig.get('test%d'%test_nr, 'flows')) |