Last active
October 8, 2018 21:35
-
-
Save yulis/67a748a21e78ea461b42 to your computer and use it in GitHub Desktop.
IPerf tests by Jimmy Cullen (http://www.jb.man.ac.uk/~jcullen/code/python/iperf_tests.py)
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| #!/usr/bin/env python | |
| ################################ | |
| # Jimmy Cullen # | |
| # Version 1.0, 2011-05-10 # | |
| # The University of Manchester # | |
| ################################ | |
| # Python script to graph iperf test results from the bash script found at: | |
| # http://www.jb.man.ac.uk/~jcullen/code/bash/iperf_tests_1.1.sh | |
| # Data recorded in the output of the script on the client machine is int the | |
| # form of four rows per test: | |
| # line 1 - iperf command line run on client | |
| # line 2 - summary of the test | |
| # line 3 - csv output for the forward direction test | |
| # line 4 - csv output for the reverse direction test | |
| # csv output is as follows: | |
| # date and time, server IP, server port, client IP, client port, iperf process number, time interval, amount of data transferred (bytes), bandwidth (bits per second), jitter (milliseconds), number of lost datagrams, total number of datagrams sent, percentage loss, number of datagrams received out of order | |
| # e.g. | |
| # 20110503113013,192.168.10.206,5001,192.168.10.100,32971,3,0.0-10.0,627420932,501941865,0.002,1,69932,0.001,0 | |
| import sys | |
| import numpy as np | |
| import pylab | |
| import re | |
| colours = ['b','g','r','c','m','y','k'] | |
| symbols = ['-', '--', '-.', ':', '.', ',', 'o', 'v', '^', '<', '>', '1', '2', '3', '4', 's', 'p', '*', 'h', 'H', '+', 'x', 'D', 'd', '|', '_'] | |
| pkt_size_arr = [1000, 1472, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 8972] | |
| bandwidth = [] | |
| for a in xrange(100, 10100, 100): | |
| bandwidth.append(a) | |
| cmd_line = [] | |
| client_data = [] | |
| forward_data = [] | |
| reverse_data = [] | |
| # get filename | |
| if len(sys.argv) < 2: | |
| print "Too few command line arguments!" | |
| else: | |
| input_file = sys.argv[1] | |
| common_root = input_file[18:-4] | |
| # read in iperf data into a variable called data | |
| f = open(input_file, 'r') | |
| data = f.readlines() | |
| f.close() | |
| for line in data: | |
| if re.search(r'^/', line): | |
| # place copy in cmd_line array | |
| cmd_line.append(line.rstrip()) | |
| # sanity checks: | |
| # - make sure the next line exists (NB len is +1 the index position) | |
| # - make sure the next lines begin with numbers | |
| if len(data)-1 >= data.index(line)+1 and re.search(r'^[0-9]', data[data.index(line)+1]): | |
| # add the next line to client_data array | |
| client_data.append(data[data.index(line) + 1].rstrip()) | |
| if len(data)-1 >= data.index(line)+2 and re.search(r'^[0-9]', data[data.index(line)+2]): | |
| # add the next line to forward_data array | |
| forward_data.append(data[data.index(line) + 2].rstrip()) | |
| if len(data)-1 >= data.index(line)+3 and re.search(r'^[0-9]', data[data.index(line)+3]): | |
| # add the next line to reverse_data array | |
| reverse_data.append(data[data.index(line) + 3].rstrip()) | |
| # define some lists | |
| cmd_line_bandwidth = [] | |
| cmd_line_pkt_size = [] | |
| client_data_data_transferred = [] | |
| client_data_bandwidth = [] | |
| forward_data_data_transferred = [] | |
| forward_data_bandwidth = [] | |
| forward_data_jitter = [] | |
| forward_data_lost_datagrams = [] | |
| forward_data_total_datagrams = [] | |
| forward_data_packets_out_of_order = [] | |
| reverse_data_data_transferred = [] | |
| reverse_data_bandwidth = [] | |
| reverse_data_jitter = [] | |
| reverse_data_lost_datagrams = [] | |
| reverse_data_total_datagrams = [] | |
| reverse_data_packets_out_of_order = [] | |
| # cmd_line | |
| for k in range(len(cmd_line)): | |
| cmd_line_bandwidth.append(int(cmd_line[k].split()[5][:-1])) | |
| cmd_line_pkt_size.append(int(cmd_line[k].split()[9][:-1])) | |
| # client_data | |
| for l in range(len(client_data)): | |
| client_data_bandwidth.append(int(client_data[l].split(',')[7])/1000000) | |
| client_data_data_transferred.append(int(client_data[l].split(',')[8])/1000000) | |
| # forward_data | |
| for m in range(len(forward_data)): | |
| forward_data_data_transferred.append(int(forward_data[m].split(',')[7])/1000000) | |
| forward_data_bandwidth.append(int(forward_data[m].split(',')[8])/1000000) | |
| forward_data_jitter.append(forward_data[m].split(',')[9]) | |
| forward_data_lost_datagrams.append(int(forward_data[m].split(',')[10])) | |
| forward_data_total_datagrams.append(int(forward_data[m].split(',')[11])) | |
| forward_data_packets_out_of_order.append(int(forward_data[m].split(',')[13])) | |
| # reverse_data | |
| for m in range(len(reverse_data)): | |
| reverse_data_data_transferred.append(int(reverse_data[m].split(',')[7])/1000000) | |
| reverse_data_bandwidth.append(int(reverse_data[m].split(',')[8])/1000000) | |
| reverse_data_jitter.append(reverse_data[m].split(',')[9]) | |
| reverse_data_lost_datagrams.append(int(reverse_data[m].split(',')[10])) | |
| reverse_data_total_datagrams.append(int(reverse_data[m].split(',')[11])) | |
| reverse_data_packets_out_of_order.append(int(reverse_data[m].split(',')[13])) | |
| # Make some plots | |
| ################################################################ | |
| ### 1a Requested bandwidth vs. achieved bandwidth (forward) | |
| ################################################################ | |
| pylab.figure() | |
| col = 0 | |
| sym = 0 | |
| for qf in pkt_size_arr: | |
| temp1f = [] | |
| temp2f = [] | |
| for pf in range(len(cmd_line_pkt_size)): | |
| if qf == cmd_line_pkt_size[pf]: | |
| temp1f.append(cmd_line_bandwidth[pf]) | |
| temp2f.append(forward_data_bandwidth[pf]) | |
| pylab.plot(temp1f, temp2f, colours[col]+symbols[sym], label = repr(qf)) | |
| pylab.grid(True) | |
| pylab.xlabel('Requested Bandwidth (Mbps)') | |
| pylab.ylabel('Achieved Bandwidth (Mbps)') | |
| pylab.title('Requested versus achieved UDP bandwidth\nfor varying datagram sizes (forward)') | |
| # increment colour and symbols | |
| if col < 6: | |
| col = col+1 | |
| else: | |
| col = 0 | |
| sym = sym+1 | |
| # add legend | |
| pylab.legend(loc='best') | |
| pylab.savefig('req_bw_vs_ach_bw_forward_' + common_root) | |
| ################################################################ | |
| ### 1b Requested bandwidth vs. achieved bandwidth (reverse) | |
| ################################################################ | |
| pylab.figure() | |
| col = 0 | |
| sym = 0 | |
| for qr in pkt_size_arr: | |
| temp1r = [] | |
| temp2r = [] | |
| for pr in range(len(cmd_line_pkt_size)): | |
| if qr == cmd_line_pkt_size[pr]: | |
| temp1r.append(cmd_line_bandwidth[pr]) | |
| temp2r.append(reverse_data_bandwidth[pr]) | |
| pylab.plot(temp1r, temp2r, colours[col]+symbols[sym], label = repr(qr)) | |
| pylab.grid(True) | |
| pylab.xlabel('Requested Bandwidth (Mbps)') | |
| pylab.ylabel('Achieved Bandwidth (Mbps)') | |
| pylab.title('Requested versus achieved UDP bandwidth\nfor varying datagram sizes (reverse)') | |
| # increment colour and symbols | |
| if col < 6: | |
| col = col+1 | |
| else: | |
| col = 0 | |
| sym = sym+1 | |
| # add legend | |
| pylab.legend(loc='best') | |
| pylab.savefig('req_bw_vs_ach_bw_reverse_' + common_root) | |
| ################################################################ | |
| ### 2a Requested bandwidth vs. jitter (forward) | |
| ################################################################ | |
| pylab.figure() | |
| col = 0 | |
| sym = 0 | |
| for qqf in pkt_size_arr: | |
| temp3f = [] | |
| temp4f = [] | |
| for ppf in range(len(cmd_line_pkt_size)): | |
| if qqf == cmd_line_pkt_size[ppf]: | |
| temp3f.append(cmd_line_bandwidth[ppf]) | |
| temp4f.append(forward_data_jitter[ppf]) | |
| pylab.plot(temp3f, temp4f, colours[col]+symbols[sym], label = repr(qqf)) | |
| pylab.grid(True) | |
| pylab.xlabel('Requested Bandwidth (Mbps)') | |
| pylab.ylabel('Jitter (microseconds)') | |
| pylab.title('Requested UDP bandwidth versus jitter\nfor varying datagram sizes (forward)') | |
| # increment colour and symbols | |
| if col < 6: | |
| col = col+1 | |
| else: | |
| col = 0 | |
| sym = sym+1 | |
| # add legend | |
| pylab.legend(loc='best') | |
| pylab.savefig('req_bw_vs_jitter_forward_' + common_root) | |
| ################################################################ | |
| ### 2b Requested bandwidth vs. jitter (reverse) | |
| ################################################################ | |
| pylab.figure() | |
| col = 0 | |
| sym = 0 | |
| for qqr in pkt_size_arr: | |
| temp3r = [] | |
| temp4r = [] | |
| for ppr in range(len(cmd_line_pkt_size)): | |
| if qqr == cmd_line_pkt_size[ppr]: | |
| temp3r.append(cmd_line_bandwidth[ppr]) | |
| temp4r.append(reverse_data_jitter[ppr]) | |
| pylab.plot(temp3r, temp4r, colours[col]+symbols[sym], label = repr(qqr)) | |
| pylab.grid(True) | |
| pylab.xlabel('Requested Bandwidth (Mbps)') | |
| pylab.ylabel('Jitter (microseconds)') | |
| pylab.title('Requested UDP bandwidth versus jitter\nfor varying datagram sizes (reverse)') | |
| # increment colour and symbols | |
| if col < 6: | |
| col = col+1 | |
| else: | |
| col = 0 | |
| sym = sym+1 | |
| # add legend | |
| pylab.legend(loc='best') | |
| pylab.savefig('req_bw_vs_jitter_reverse_' + common_root) | |
| ################################################################ | |
| ### 3a Requested bandwidth vs. percentage lost packets (forward) | |
| ################################################################ | |
| pylab.figure() | |
| col = 0 | |
| sym = 0 | |
| for qqqf in pkt_size_arr: | |
| temp5f = [] | |
| temp6f = [] | |
| for pppf in range(len(cmd_line_pkt_size)): | |
| if qqqf == cmd_line_pkt_size[pppf]: | |
| temp5f.append(cmd_line_bandwidth[pppf]) | |
| temp6f.append(float(forward_data_lost_datagrams[pppf])/float(forward_data_total_datagrams[pppf])* 100) | |
| pylab.plot(temp5f, temp6f, colours[col]+symbols[sym], label = repr(qqqf)) | |
| pylab.grid(True) | |
| pylab.xlabel('Requested Bandwidth (Mbps)') | |
| pylab.ylabel('Percentage lost packets') | |
| pylab.title('Requested bandwidth versus percentage packet loss\nfor varying datagram sizes (forward)') | |
| # increment colour and symbols | |
| if col < 6: | |
| col = col+1 | |
| else: | |
| col = 0 | |
| sym = sym+1 | |
| pylab.legend(loc='best') | |
| pylab.savefig('req_bw_vs_pcnt_pkt_loss_forward_' + common_root) | |
| ################################################################ | |
| ### 3b Requested bandwidth vs. percentage lost packets (reverse) | |
| ################################################################ | |
| pylab.figure() | |
| col = 0 | |
| sym = 0 | |
| for qqqr in pkt_size_arr: | |
| temp5r = [] | |
| temp6r = [] | |
| for pppr in range(len(cmd_line_pkt_size)): | |
| if qqqr == cmd_line_pkt_size[pppr]: | |
| temp5r.append(cmd_line_bandwidth[pppr]) | |
| temp6r.append(float(reverse_data_lost_datagrams[pppr])/float(reverse_data_total_datagrams[pppr])* 100) | |
| pylab.plot(temp5r, temp6r, colours[col]+symbols[sym], label = repr(qqqr)) | |
| pylab.grid(True) | |
| pylab.xlabel('Requested Bandwidth (Mbps)') | |
| pylab.ylabel('Percentage lost packets') | |
| pylab.title('Requested bandwidth versus percentage packet loss\nfor varying datagram sizes (reverse)') | |
| # increment colour and symbols | |
| if col < 6: | |
| col = col+1 | |
| else: | |
| col = 0 | |
| sym = sym+1 | |
| pylab.legend(loc='best') | |
| pylab.savefig('req_bw_vs_pcnt_pkt_loss_reverse_' + common_root) | |
| ################################################################ | |
| ### 4a Requested bandwidth vs. out of order packets (forward) | |
| ################################################################ | |
| pylab.figure() | |
| col = 0 | |
| sym = 0 | |
| for qqqqf in pkt_size_arr: | |
| temp7f = [] | |
| temp8f = [] | |
| for ppppf in range(len(cmd_line_pkt_size)): | |
| if qqqqf == cmd_line_pkt_size[ppppf]: | |
| temp7f.append(cmd_line_bandwidth[ppppf]) | |
| temp8f.append(forward_data_packets_out_of_order[ppppf]) | |
| pylab.plot(temp7f, temp8f, colours[col]+symbols[sym], label = repr(qqqqf)) | |
| pylab.grid(True) | |
| pylab.xlabel('Requested Bandwidth (Mbps)') | |
| pylab.ylabel('Out of order packets') | |
| pylab.title('Requested bandwidth versus out of order packets\nfor varying datagram sizes (forward)') | |
| # increment colour and symbols | |
| if col < 6: | |
| col = col+1 | |
| else: | |
| col = 0 | |
| sym = sym+1 | |
| pylab.legend(loc='best') | |
| pylab.savefig('req_bw_vs_out_of_order_forward_' + common_root) | |
| ################################################################ | |
| ### 4b Requested bandwidth vs. out of order packets (reverse) | |
| ################################################################ | |
| pylab.figure() | |
| col = 0 | |
| sym = 0 | |
| for qqqqr in pkt_size_arr: | |
| temp7r = [] | |
| temp8r = [] | |
| for ppppr in range(len(cmd_line_pkt_size)): | |
| if qqqqr == cmd_line_pkt_size[ppppr]: | |
| temp7r.append(cmd_line_bandwidth[ppppr]) | |
| temp8r.append(forward_data_packets_out_of_order[ppppr]) | |
| pylab.plot(temp7r, temp8r, colours[col]+symbols[sym], label = repr(qqqqr)) | |
| pylab.grid(True) | |
| pylab.xlabel('Requested Bandwidth (Mbps)') | |
| pylab.ylabel('Out of order packets') | |
| pylab.title('Requested bandwidth versus out of order packets\nfor varying datagram sizes (reverse)') | |
| # increment colour and symbols | |
| if col < 6: | |
| col = col+1 | |
| else: | |
| col = 0 | |
| sym = sym+1 | |
| pylab.legend(loc='best') | |
| pylab.savefig('req_bw_vs_out_of_order_reverse_' + common_root) | |
| # display the plots | |
| pylab.show() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
hi,
how are you Sir,
am PhD student, am facing a big issue, kindly your help is highly appreciate.
i had run this code first by python iperf_tests.py, but it doesn't executed.
then i run iperf in client and execute the code.
i have 10 lxc container configure as routers, and 4 host as sucrose want to communicate all with another hos as destination. beside i have two type of traffic flow, one best effort and another is sensitive delay.
please kindly i need your help, how can i execute this code, i need to capture the output plot the output as given in the code, this code is really fit on my work.
your work is highly appreciate.
thank you.
my email is [email protected].
hopefully i can get reply thank you Sir