From 837fc0385061a75a5bd172e850c8716ab038c3a7 Mon Sep 17 00:00:00 2001 From: Luc Provoost Date: Mon, 27 Jan 2020 10:14:09 -0500 Subject: Code review feedback & back-ground traffic support Various code review comments taken into account. We also support now background traffic, meaning the scripts will start a test between machines and monitor packet loss, latency, etc., but at the same time, the script will also start traffic on background machines. That traffic will not be monitored. Each generator will generate the same ammoung of traffic. Change-Id: I5cd495be230a526f91de965f3d4dd0581681f5ca Signed-off-by: Luc Provoost --- VNFs/DPPD-PROX/helper-scripts/rapid/runrapid.py | 279 ++++++++++++++---------- 1 file changed, 162 insertions(+), 117 deletions(-) (limited to 'VNFs/DPPD-PROX') 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')) -- cgit 1.2.3-korg