tools/plot/fio2gnuplot

   1 #!/usr/bin/python2.7
   2 # Note: this script is python2 and python3 compatible.
   3 #
   4 #  Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
   5 #  Author: Erwan Velu  <erwan@enovance.com>
   6 #
   7 #  The license below covers all files distributed with fio unless otherwise
   8 #  noted in the file itself.
   9 #
  10 #  This program is free software; you can redistribute it and/or modify
  11 #  it under the terms of the GNU General Public License version 2 as
  12 #  published by the Free Software Foundation.
  13 #
  14 #  This program is distributed in the hope that it will be useful,
  15 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 #  GNU General Public License for more details.
  18 #
  19 #  You should have received a copy of the GNU General Public License
  20 #  along with this program; if not, write to the Free Software
  21 #  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  22
  23 from __future__ import absolute_import
  24 from __future__ import print_function
  25 import os
  26 import fnmatch
  27 import sys
  28 import getopt
  29 import re
  30 import math
  31 import shutil
  32 from six.moves import map
  33 from six.moves import range
  34
  35 def find_file(path, pattern):
  36         fio_data_file=[]
  37         # For all the local files
  38         for file in os.listdir(path):
  39                 # If the file matches the glob
  40                 if fnmatch.fnmatch(file, pattern):
  41                         # Let's consider this file
  42                         fio_data_file.append(file)
  43
  44         return fio_data_file
  45
  46 def generate_gnuplot_script(fio_data_file,title,gnuplot_output_filename,gnuplot_output_dir,mode,disk_perf,gpm_dir):
  47         if verbose: print("Generating rendering scripts")
  48         filename=gnuplot_output_dir+'mygraph'
  49         temporary_files.append(filename)
  50         f=open(filename,'w')
  51
  52         # Plotting 3D or comparing graphs doesn't have a meaning unless if there is at least 2 traces
  53         if len(fio_data_file) > 1:
  54                 f.write("call \'%s/graph3D.gpm\' \'%s' \'%s\' \'\' \'%s\' \'%s\'\n" % (gpm_dir,title,gnuplot_output_filename,gnuplot_output_filename,mode))
  55
  56                 # Setting up the compare files that will be plot later
  57                 compare=open(gnuplot_output_dir + 'compare.gnuplot','w')
  58                 compare.write('''
  59 set title '%s'
  60 set terminal png size 1280,1024
  61 set ytics axis out auto
  62 set key top left reverse
  63 set xlabel "Time (Seconds)"
  64 set ylabel '%s'
  65 set yrange [0:]
  66 set style line 1 lt 1 lw 3 pt 3 linecolor rgb "green"
  67 '''% (title,mode))
  68                 compare.close()
  69                 #Copying the common file for all kind of graph (raw/smooth/trend)
  70                 compare_raw_filename="compare-%s-2Draw" % (gnuplot_output_filename)
  71                 compare_smooth_filename="compare-%s-2Dsmooth" % (gnuplot_output_filename)
  72                 compare_trend_filename="compare-%s-2Dtrend" % (gnuplot_output_filename)
  73
  74                 shutil.copy(gnuplot_output_dir+'compare.gnuplot',gnuplot_output_dir+compare_raw_filename+".gnuplot")
  75                 shutil.copy(gnuplot_output_dir+'compare.gnuplot',gnuplot_output_dir+compare_smooth_filename+".gnuplot")
  76                 shutil.copy(gnuplot_output_dir+'compare.gnuplot',gnuplot_output_dir+compare_trend_filename+".gnuplot")
  77                 temporary_files.append(gnuplot_output_dir+compare_raw_filename+".gnuplot")
  78                 temporary_files.append(gnuplot_output_dir+compare_smooth_filename+".gnuplot")
  79                 temporary_files.append(gnuplot_output_dir+compare_trend_filename+".gnuplot")
  80
  81                 #Setting up a different output filename for each kind of graph
  82                 compare_raw=open(gnuplot_output_dir+compare_raw_filename + ".gnuplot",'a')
  83                 compare_raw.write("set output '%s.png'\n" % compare_raw_filename)
  84                 compare_smooth=open(gnuplot_output_dir+compare_smooth_filename+".gnuplot",'a')
  85                 compare_smooth.write("set output '%s.png'\n" % compare_smooth_filename)
  86                 compare_trend=open(gnuplot_output_dir+compare_trend_filename+".gnuplot",'a')
  87                 compare_trend.write("set output '%s.png'\n" % compare_trend_filename)
  88
  89                 # Let's plot the average value for all the traces
  90                 global_disk_perf = sum(disk_perf, [])
  91                 global_avg  = average(global_disk_perf)
  92                 compare_raw.write("plot %s w l ls 1 ti 'Global average value (%.2f)'" % (global_avg,global_avg));
  93                 compare_smooth.write("plot %s w l ls 1 ti 'Global average value (%.2f)'" % (global_avg,global_avg));
  94                 compare_trend.write("plot %s w l ls 1 ti 'Global average value (%.2f)'" % (global_avg,global_avg));
  95
  96                 pos=0
  97                 # Let's create a temporary file for each selected fio file
  98                 for file in fio_data_file:
  99                         tmp_filename = "gnuplot_temp_file.%d" % pos
 100
 101                 # Plotting comparing graphs doesn't have a meaning unless if there is at least 2 traces
 102                 if len(fio_data_file) > 1:
 103                         # Adding the plot instruction for each kind of comparing graphs
 104                         compare_raw.write(",\\\n'%s' using 2:3 with linespoints title '%s'" % (tmp_filename,fio_data_file[pos]))
 105                         compare_smooth.write(",\\\n'%s' using 2:3 smooth csplines title '%s'" % (tmp_filename,fio_data_file[pos]))
 106                         compare_trend.write(",\\\n'%s' using 2:3 smooth bezier title '%s'" % (tmp_filename,fio_data_file[pos]))
 107
 108                 png_file=file.replace('.log','')
 109                 raw_filename = "%s-2Draw" % (png_file)
 110                 smooth_filename = "%s-2Dsmooth" % (png_file)
 111                 trend_filename = "%s-2Dtrend" % (png_file)
 112                 avg  = average(disk_perf[pos])
 113                 f.write("call \'%s/graph2D.gpm\' \'%s' \'%s\' \'%s\' \'%s\' \'%s\' \'%s\' \'%s\' \'%f\'\n" % (gpm_dir,title,tmp_filename,fio_data_file[pos],raw_filename,mode,smooth_filename,trend_filename,avg))
 114                 pos = pos +1
 115
 116         # Plotting comparing graphs doesn't have a meaning unless if there is at least 2 traces
 117         if len(fio_data_file) > 1:
 118                 os.remove(gnuplot_output_dir+"compare.gnuplot")
 119                 compare_raw.close()
 120                 compare_smooth.close()
 121                 compare_trend.close()
 122         f.close()
 123
 124 def generate_gnuplot_math_script(title,gnuplot_output_filename,mode,average,gnuplot_output_dir,gpm_dir):
 125         filename=gnuplot_output_dir+'mymath';
 126         temporary_files.append(filename)
 127         f=open(filename,'a')
 128         f.write("call \'%s/math.gpm\' \'%s' \'%s\' \'\' \'%s\' \'%s\' %s\n" % (gpm_dir,title,gnuplot_output_filename,gnuplot_output_filename,mode,average))
 129         f.close()
 130
 131 def compute_aggregated_file(fio_data_file, gnuplot_output_filename, gnuplot_output_dir):
 132         if verbose: print("Processing data file 2/2")
 133         temp_files=[]
 134         pos=0
 135
 136         # Let's create a temporary file for each selected fio file
 137         for file in fio_data_file:
 138                 tmp_filename = "%sgnuplot_temp_file.%d" % (gnuplot_output_dir, pos)
 139                 temp_files.append(open(tmp_filename,'r'))
 140                 pos = pos +1
 141
 142         f = open(gnuplot_output_dir+gnuplot_output_filename, "w")
 143         temporary_files.append(gnuplot_output_dir+gnuplot_output_filename)
 144         index=0
 145         # Let's add some information
 146         for tempfile in temp_files:
 147                     f.write("# Disk%d was coming from %s\n" % (index,fio_data_file[index]))
 148                     f.write(tempfile.read())
 149                     f.write("\n")
 150                     tempfile.close()
 151                     index = index + 1
 152         f.close()
 153
 154 def average(s): return sum(s) * 1.0 / len(s)
 155
 156 def compute_temp_file(fio_data_file,disk_perf,gnuplot_output_dir, min_time, max_time):
 157         end_time=max_time
 158         if end_time == -1:
 159                 end_time="infinite"
 160         if verbose: print("Processing data file 1/2 with %s<time<%s" % (min_time,end_time))
 161         files=[]
 162         temp_outfile=[]
 163         blk_size=0
 164         for file in fio_data_file:
 165                 files.append(open(file))
 166                 pos = len(files) - 1
 167                 tmp_filename = "%sgnuplot_temp_file.%d" % (gnuplot_output_dir,pos)
 168                 temporary_files.append(tmp_filename)
 169                 gnuplot_file=open(tmp_filename,'w')
 170                 temp_outfile.append(gnuplot_file)
 171                 gnuplot_file.write("#Temporary file based on file %s\n" % file)
 172                 disk_perf.append([])
 173
 174         shall_break = False
 175         while True:
 176                 current_line=[]
 177                 nb_empty_files=0
 178                 nb_files=len(files)
 179                 for myfile in files:
 180                         s=myfile.readline().replace(',',' ').split()
 181                         if not s:
 182                                 nb_empty_files+=1
 183                                 s="-1, 0, 0, 0".replace(',',' ').split()
 184
 185                         if (nb_empty_files == nb_files):
 186                                 shall_break=True
 187                                 break;
 188
 189                         current_line.append(s);
 190
 191                 if shall_break == True:
 192                         break
 193
 194                 last_time = -1
 195                 index=-1
 196                 perfs=[]
 197                 for line in enumerate(current_line):
 198                         # Index will be used to remember what file was featuring what value
 199                         index=index+1
 200
 201                         time, perf, x, block_size = line[1]
 202                         if (blk_size == 0):
 203                                 try:
 204                                         blk_size=int(block_size)
 205                                 except:
 206                                         print("Error while reading the following line :")
 207                                         print(line)
 208                                         sys.exit(1);
 209
 210                         # We ignore the first 500msec as it doesn't seems to be part of the real benchmark
 211                         # Time < 500 usually reports BW=0 breaking the min computing
 212                         if (min_time == 0):
 213                                 min_time==0.5
 214
 215                         # Then we estimate if the data we got is part of the time range we want to plot
 216                         if ((float(time)>(float(min_time)*1000)) and ((int(time) < (int(max_time)*1000)) or max_time==-1)):
 217                                         disk_perf[index].append(int(perf))
 218                                         perfs.append("%d %s %s"% (index, time, perf))
 219
 220                 # If we reach this point, it means that all the traces are coherent
 221                 for p in enumerate(perfs):
 222                         index, perf_time,perf = p[1].split()
 223                         temp_outfile[int(index)].write("%s %.2f %s\n" % (index, float(float(perf_time)/1000), perf))
 224
 225
 226         for file in files:
 227                 file.close()
 228         for file in temp_outfile:
 229                 file.close()
 230         return blk_size
 231
 232 def compute_math(fio_data_file, title,gnuplot_output_filename,gnuplot_output_dir,mode,disk_perf,gpm_dir):
 233         if verbose: print("Computing Maths")
 234         global_min=[]
 235         global_max=[]
 236         average_file=open(gnuplot_output_dir+gnuplot_output_filename+'.average', 'w')
 237         min_file=open(gnuplot_output_dir+gnuplot_output_filename+'.min', 'w')
 238         max_file=open(gnuplot_output_dir+gnuplot_output_filename+'.max', 'w')
 239         stddev_file=open(gnuplot_output_dir+gnuplot_output_filename+'.stddev', 'w')
 240         global_file=open(gnuplot_output_dir+gnuplot_output_filename+'.global','w')
 241         temporary_files.append(gnuplot_output_dir+gnuplot_output_filename+'.average')
 242         temporary_files.append(gnuplot_output_dir+gnuplot_output_filename+'.min')
 243         temporary_files.append(gnuplot_output_dir+gnuplot_output_filename+'.max')
 244         temporary_files.append(gnuplot_output_dir+gnuplot_output_filename+'.stddev')
 245         temporary_files.append(gnuplot_output_dir+gnuplot_output_filename+'.global')
 246
 247         min_file.write('DiskName %s\n' % mode)
 248         max_file.write('DiskName %s\n'% mode)
 249         average_file.write('DiskName %s\n'% mode)
 250         stddev_file.write('DiskName %s\n'% mode )
 251         for disk in range(len(fio_data_file)):
 252 #               print disk_perf[disk]
 253                 min_file.write("# Disk%d was coming from %s\n" % (disk,fio_data_file[disk]))
 254                 max_file.write("# Disk%d was coming from %s\n" % (disk,fio_data_file[disk]))
 255                 average_file.write("# Disk%d was coming from %s\n" % (disk,fio_data_file[disk]))
 256                 stddev_file.write("# Disk%d was coming from %s\n" % (disk,fio_data_file[disk]))
 257                 avg  = average(disk_perf[disk])
 258                 variance = [(x - avg)**2 for x in disk_perf[disk]]
 259                 standard_deviation = math.sqrt(average(variance))
 260 #               print "Disk%d [ min=%.2f max=%.2f avg=%.2f stddev=%.2f \n" % (disk,min(disk_perf[disk]),max(disk_perf[disk]),avg, standard_deviation)
 261                 average_file.write('%d %d\n' % (disk, avg))
 262                 stddev_file.write('%d %d\n' % (disk, standard_deviation))
 263                 local_min=min(disk_perf[disk])
 264                 local_max=max(disk_perf[disk])
 265                 min_file.write('%d %d\n' % (disk, local_min))
 266                 max_file.write('%d %d\n' % (disk, local_max))
 267                 global_min.append(int(local_min))
 268                 global_max.append(int(local_max))
 269
 270         global_disk_perf = sum(disk_perf, [])
 271         avg  = average(global_disk_perf)
 272         variance = [(x - avg)**2 for x in global_disk_perf]
 273         standard_deviation = math.sqrt(average(variance))
 274
 275         global_file.write('min=%.2f\n' % min(global_disk_perf))
 276         global_file.write('max=%.2f\n' % max(global_disk_perf))
 277         global_file.write('avg=%.2f\n' % avg)
 278         global_file.write('stddev=%.2f\n' % standard_deviation)
 279         global_file.write('values_count=%d\n' % len(global_disk_perf))
 280         global_file.write('disks_count=%d\n' % len(fio_data_file))
 281         #print "Global [ min=%.2f max=%.2f avg=%.2f stddev=%.2f \n" % (min(global_disk_perf),max(global_disk_perf),avg, standard_deviation)
 282
 283         average_file.close()
 284         min_file.close()
 285         max_file.close()
 286         stddev_file.close()
 287         global_file.close()
 288         try:
 289                 os.remove(gnuplot_output_dir+'mymath')
 290         except:
 291                 True
 292
 293         generate_gnuplot_math_script("Average values of "+title,gnuplot_output_filename+'.average',mode,int(avg),gnuplot_output_dir,gpm_dir)
 294         generate_gnuplot_math_script("Min values of "+title,gnuplot_output_filename+'.min',mode,average(global_min),gnuplot_output_dir,gpm_dir)
 295         generate_gnuplot_math_script("Max values of "+title,gnuplot_output_filename+'.max',mode,average(global_max),gnuplot_output_dir,gpm_dir)
 296         generate_gnuplot_math_script("Standard Deviation of "+title,gnuplot_output_filename+'.stddev',mode,int(standard_deviation),gnuplot_output_dir,gpm_dir)
 297
 298 def parse_global_files(fio_data_file, global_search):
 299         max_result=0
 300         max_file=''
 301         for file in fio_data_file:
 302                 f=open(file)
 303                 disk_count=0
 304                 search_value=-1
 305
 306                 # Let's read the complete file
 307                 while True:
 308                         try:
 309                                 # We do split the name from the value
 310                                 name,value=f.readline().split("=")
 311                         except:
 312                                 f.close()
 313                                 break
 314                         # If we ended the file
 315                         if not name:
 316                                 # Let's process what we have
 317                                 f.close()
 318                                 break
 319                         else:
 320                                 # disks_count is not global_search item
 321                                 # As we need it for some computation, let's save it
 322                                 if name=="disks_count":
 323                                         disks_count=int(value)
 324
 325                                 # Let's catch the searched item
 326                                 if global_search in name:
 327                                         search_value=float(value)
 328
 329                 # Let's process the avg value by estimated the global bandwidth per file
 330                 # We keep the biggest in memory for reporting
 331                 if global_search == "avg":
 332                         if (disks_count > 0) and (search_value != -1):
 333                                 result=disks_count*search_value
 334                                 if (result > max_result):
 335                                         max_result=result
 336                                         max_file=file
 337         # Let's print the avg output
 338         if global_search == "avg":
 339                 print("Biggest aggregated value of %s was %2.f in file %s\n" % (global_search, max_result, max_file))
 340         else:
 341                 print("Global search %s is not yet implemented\n" % global_search)
 342
 343 def render_gnuplot(fio_data_file, gnuplot_output_dir):
 344         print("Running gnuplot Rendering")
 345         try:
 346                 # Let's render all the compared files if some
 347                 if len(fio_data_file) > 1:
 348                         if verbose: print(" |-> Rendering comparing traces")
 349                         os.system("cd %s; for i in *.gnuplot; do gnuplot $i; done" % gnuplot_output_dir)
 350                 if verbose: print(" |-> Rendering math traces")
 351                 os.system("cd %s; gnuplot mymath" % gnuplot_output_dir)
 352                 if verbose: print(" |-> Rendering 2D & 3D traces")
 353                 os.system("cd %s; gnuplot mygraph" % gnuplot_output_dir)
 354
 355                 name_of_directory="the current"
 356                 if gnuplot_output_dir != "./":
 357                         name_of_directory=gnuplot_output_dir
 358                 print("\nRendering traces are available in %s directory" % name_of_directory)
 359                 global keep_temp_files
 360                 keep_temp_files=False
 361         except:
 362                 print("Could not run gnuplot on mymath or mygraph !\n")
 363                 sys.exit(1);
 364
 365 def print_help():
 366     print('fio2gnuplot -ghbiodvk -t <title> -o <outputfile> -p <pattern> -G <type> -m <time> -M <time>')
 367     print()
 368     print('-h --help                           : Print this help')
 369     print('-p <pattern> or --pattern <pattern> : A glob pattern to select fio input files')
 370     print('-b           or --bandwidth         : A predefined pattern for selecting *_bw.log files')
 371     print('-i           or --iops              : A predefined pattern for selecting *_iops.log files')
 372     print('-g           or --gnuplot           : Render gnuplot traces before exiting')
 373     print('-o           or --outputfile <file> : The basename for gnuplot traces')
 374     print('                                       - Basename is set with the pattern if defined')
 375     print('-d           or --outputdir <dir>   : The directory where gnuplot shall render files')
 376     print('-t           or --title <title>     : The title of the gnuplot traces')
 377     print('                                       - Title is set with the block size detected in fio traces')
 378     print('-G           or --Global <type>     : Search for <type> in .global files match by a pattern')
 379     print('                                       - Available types are : min, max, avg, stddev')
 380     print('                                       - The .global extension is added automatically to the pattern')
 381     print('-m           or --min_time <time>   : Only consider data starting from <time> seconds (default is 0)')
 382     print('-M           or --max_time <time>   : Only consider data ending before <time> seconds (default is -1 aka nolimit)')
 383     print('-v           or --verbose           : Increasing verbosity')
 384     print('-k           or --keep              : Keep all temporary files from gnuplot\'s output dir')
 385
 386 def main(argv):
 387     mode='unknown'
 388     pattern=''
 389     pattern_set_by_user=False
 390     title='No title'
 391     gnuplot_output_filename='result'
 392     gnuplot_output_dir='./'
 393     gpm_dir="/usr/share/fio/"
 394     disk_perf=[]
 395     run_gnuplot=False
 396     parse_global=False
 397     global_search=''
 398     min_time=0
 399     max_time=-1
 400     global verbose
 401     verbose=False
 402     global temporary_files
 403     temporary_files=[]
 404     global keep_temp_files
 405     keep_temp_files=True
 406     force_keep_temp_files=False
 407
 408     if not os.path.isfile(gpm_dir+'math.gpm'):
 409         gpm_dir="/usr/local/share/fio/"
 410         if not os.path.isfile(gpm_dir+'math.gpm'):
 411             print("Looks like fio didn't get installed properly as no gpm files found in '/usr/share/fio' or '/usr/local/share/fio'\n")
 412             sys.exit(3)
 413
 414     try:
 415         opts, args = getopt.getopt(argv[1:],"ghkbivo:d:t:p:G:m:M:",['bandwidth', 'iops', 'pattern', 'outputfile', 'outputdir', 'title', 'min_time', 'max_time', 'gnuplot', 'Global', 'help', 'verbose','keep'])
 416     except getopt.GetoptError:
 417         print("Error: One of the options passed to the cmdline was not supported")
 418         print("Please fix your command line or read the help (-h option)")
 419         sys.exit(2)
 420
 421     for opt, arg in opts:
 422         if opt in ("-b", "--bandwidth"):
 423             pattern='*_bw.log'
 424         elif opt in ("-i", "--iops"):
 425             pattern='*_iops.log'
 426         elif opt in ("-v", "--verbose"):
 427             verbose=True
 428         elif opt in ("-k", "--keep"):
 429             #User really wants to keep the temporary files
 430             force_keep_temp_files=True
 431         elif opt in ("-p", "--pattern"):
 432             pattern_set_by_user=True
 433             pattern=arg
 434             pattern=pattern.replace('\\','')
 435         elif opt in ("-o", "--outputfile"):
 436             gnuplot_output_filename=arg
 437         elif opt in ("-d", "--outputdir"):
 438             gnuplot_output_dir=arg
 439             if not gnuplot_output_dir.endswith('/'):
 440                 gnuplot_output_dir=gnuplot_output_dir+'/'
 441             if not os.path.exists(gnuplot_output_dir):
 442                 os.makedirs(gnuplot_output_dir)
 443         elif opt in ("-t", "--title"):
 444             title=arg
 445         elif opt in ("-m", "--min_time"):
 446             min_time=arg
 447         elif opt in ("-M", "--max_time"):
 448             max_time=arg
 449         elif opt in ("-g", "--gnuplot"):
 450             run_gnuplot=True
 451         elif opt in ("-G", "--Global"):
 452             parse_global=True
 453             global_search=arg
 454         elif opt in ("-h", "--help"):
 455             print_help()
 456             sys.exit(1)
 457
 458     # Adding .global extension to the file
 459     if parse_global==True:
 460         if not gnuplot_output_filename.endswith('.global'):
 461             pattern = pattern+'.global'
 462
 463     fio_data_file=find_file('.',pattern)
 464     if len(fio_data_file) == 0:
 465         print("No log file found with pattern %s!" % pattern)
 466         # Try numjob log file format if per_numjob_logs=1
 467         if (pattern == '*_bw.log'):
 468             fio_data_file=find_file('.','*_bw.*.log')
 469         if (pattern == '*_iops.log'):
 470             fio_data_file=find_file('.','*_iops.*.log')
 471         if len(fio_data_file) == 0:
 472             sys.exit(1)
 473         else:
 474             print("Using log file per job format instead")
 475     else:
 476         print("%d files Selected with pattern '%s'" % (len(fio_data_file), pattern))
 477
 478     fio_data_file=sorted(fio_data_file, key=str.lower)
 479     for file in fio_data_file:
 480         print(' |-> %s' % file)
 481         if "_bw.log" in file :
 482             mode="Bandwidth (KB/sec)"
 483         if "_iops.log" in file :
 484             mode="IO per Seconds (IO/sec)"
 485     if (title == 'No title') and (mode != 'unknown'):
 486         if "Bandwidth" in mode:
 487             title='Bandwidth benchmark with %d fio results' % len(fio_data_file)
 488         if "IO" in mode:
 489             title='IO benchmark with %d fio results' % len(fio_data_file)
 490
 491     print()
 492     #We need to adjust the output filename regarding the pattern required by the user
 493     if (pattern_set_by_user == True):
 494         gnuplot_output_filename=pattern
 495         # As we do have some glob in the pattern, let's make this simpliest
 496         # We do remove the simpliest parts of the expression to get a clear file name
 497         gnuplot_output_filename=gnuplot_output_filename.replace('-*-','-')
 498         gnuplot_output_filename=gnuplot_output_filename.replace('*','-')
 499         gnuplot_output_filename=gnuplot_output_filename.replace('--','-')
 500         gnuplot_output_filename=gnuplot_output_filename.replace('.log','')
 501         # Insure that we don't have any starting or trailing dash to the filename
 502         gnuplot_output_filename = gnuplot_output_filename[:-1] if gnuplot_output_filename.endswith('-') else gnuplot_output_filename
 503         gnuplot_output_filename = gnuplot_output_filename[1:] if gnuplot_output_filename.startswith('-') else gnuplot_output_filename
 504         if (gnuplot_output_filename == ''):
 505             gnuplot_output_filename='default'
 506
 507     if parse_global==True:
 508         parse_global_files(fio_data_file, global_search)
 509     else:
 510         blk_size=compute_temp_file(fio_data_file,disk_perf,gnuplot_output_dir,min_time,max_time)
 511         title="%s @ Blocksize = %dK" % (title,blk_size/1024)
 512         compute_aggregated_file(fio_data_file, gnuplot_output_filename, gnuplot_output_dir)
 513         compute_math(fio_data_file,title,gnuplot_output_filename,gnuplot_output_dir,mode,disk_perf,gpm_dir)
 514         generate_gnuplot_script(fio_data_file,title,gnuplot_output_filename,gnuplot_output_dir,mode,disk_perf,gpm_dir)
 515
 516         if (run_gnuplot==True):
 517             render_gnuplot(fio_data_file, gnuplot_output_dir)
 518
 519         # Shall we clean the temporary files ?
 520         if keep_temp_files==False and force_keep_temp_files==False:
 521             # Cleaning temporary files
 522             if verbose: print("Cleaning temporary files")
 523             for f in enumerate(temporary_files):
 524                 if verbose: print(" -> %s"%f[1])
 525                 try:
 526                     os.remove(f[1])
 527                 except:
 528                     True
 529
 530 #Main
 531 if __name__ == "__main__":
 532     sys.exit(main(sys.argv))