def parse_path(path, myloc, direction):
newloc = [myloc[0], myloc[1]]
curDir = helpers.parseDir(direction)
if path[0].isdigit():
print('\tContinue for ' + str(path[0] + " blocks"))
newloc = helpers.move(path, curDir, myloc)
elif len(path) == 1:
curDir = helpers.turn(path, curDir)
print('\tTurn: ' + path)
elif path.replace(' ', '').isalpha():
print('\tContinue straight until you reach the ' + path)
else:
new_dir = helpers.parseDir(path[0])
newloc = helpers.move(path[1:], new_dir, myloc)
print('\tHead ' + path[0] + ' for ' + path[1:] + " blocks")
return (newloc, helpers.getDir(curDir))
def plotLatencyVsId(latencyList, idList, inputFile):
#plotting
fig, ax = plt.subplots()
linesNumber = 0
ax.plot(idList, latencyList, helpers.getBuiltInColor(linesNumber))
fig.suptitle('Latency vs Id')
ax.set_xlabel('Id')
ax.set_ylabel('Latency')
# addTimeOfFrequencyChangeAsVerticalLineOnAxis(ax, timeOfFrequencyChange)
# if x_limit > 0:
# ax.set_xlim([0, x_limit])
# ax.set_ylim([0 , percentile])
# plt.legend()
if save:
figureFilePath = helpers.getDir(inputFile) + 'latencyVsId.jpg'
print 'Saving plot to ' + figureFilePath
fig.savefig(figureFilePath, dpi=1200)
else:
plt.show()
plt.close(fig)
def plotServiceTimeVsStartTime(ServiceList, startList, inputFile, timeOfPause):
#plotting
fig, ax = plt.subplots()
linesNumber = 0
ax.plot(startList, ServiceList, helpers.getBuiltInColor(linesNumber))
fig.suptitle('Service Time vs Service Start Time')
ax.set_xlabel('Service Start Time')
ax.set_ylabel('Service Time')
addtimeOfPauseAsVerticalLineOnAxis(ax, timeOfPause)
# if x_limit > 0:
# ax.set_xlim([0, x_limit])
# ax.set_ylim([0 , percentile])
# plt.legend()
if save:
figureFilePath = helpers.getDir(inputFile) + 'serviceVsStart.jpg'
print 'Saving plot to ' + figureFilePath
fig.savefig(figureFilePath, dpi=1200)
else:
plt.show()
plt.close(fig)
#!/usr/bin/python
import BinAnalysis
import matplotlib.pyplot as plt
import sys
import helpers
# plot service time vs. memory bandwidth for
# all files passed in as arguments
bin_analysis = BinAnalysis.BinAnalysis()
fig, ax = plt.subplots()
data_file_number = 0
for bin_file in sys.argv[1:]:
bin_analysis.readBinFile(bin_file)
line_color = helpers.getBuiltInColor(data_file_number)
bin_analysis.plotDataVsMemoryBandWidth(ax, 'service_time',
line_color + '.', bin_file, True)
ax.set_xlabel('memory bandwidth (bytes)')
ax.set_ylabel('service time (ns)')
bin_analysis.clearData()
data_file_number += 1
plt.legend()
#stored in the folder of the last processeed file
dir_path = helpers.getDir(bin_file)
save_pic_path = dir_path + 'service_time_vs_MBW.jpg'
fig.savefig(save_pic_path, dpi=1200)
plt.close(fig)
bin_analysis = BinAnalysis.BinAnalysis()
fig, ax = plt.subplots()
data_file_number = 0
for input_file in sys.argv[1:]:
bin_analysis.readBinFile(input_file)
sorted_service_time_array = np.sort(bin_analysis.getList('service_time'))
sorted_service_time_list = list(sorted_service_time_array)
yvals_array = np.arange(len(sorted_service_time_list)) / float(
len(sorted_service_time_list))
yvals_list = list(yvals_array)
file_name = input_file[len(helpers.getDir(input_file)):]
ax.plot(sorted_service_time_list,
yvals_list,
helpers.getBuiltInColor(data_file_number),
label=file_name)
bin_analysis.clearData()
data_file_number += 1
fig.suptitle('Percentile vs. Service Time')
ax.set_xlabel('service time (ns)')
ax.set_ylabel('percentile')
ax.set_xlim([0, 10e6])
plt.legend()
#plt.show()
fig.savefig(helpers.getDir(input_file) + 'service_distribution.jpg', dpi=1200)
plt.close(fig)
qpsStr = (re.split('q|k|f', trialFolder))[1]
baseFolder = 'q' + qpsStr + 'base'
if not os.path.isdir(baseFolder):
helpers.pErr('Base folder ' + baseFolder + ' does not exist', 1)
#get spark start time from time file in trial folder
timeFile = trialFolder + '/' + trialFolder + '.time'
if not os.path.isfile(timeFile):
helpers.pErr('File ' + timeFile + ' does not exist', 1)
#find spark starting time
sparkStartingTime = helpers.getSparkTime(timeFile)
if not sparkStartingTime > 0:
helpers.pErr('Spark starting time not recorded in file ' + timeFile, 2)
#check to see if user wants to run get aggregate
scriptDir = helpers.getDir(sys.argv[0])
if run_get_aggregate:
print 'Running get_aggregate_data_from_csv.py'
csvFile = trialFolder + '/' + trialFolder + '.csv'
if not subprocess.call(
[scriptDir + 'get_aggregate_data_from_csv.py', csvFile]) == 0:
helpers.pErr('Unable to get aggregate data from csv file')
#check to see if aggregate data exist, if not, run script to obtain it
aggFile = trialFolder + '/' + trialFolder + '.agg'
if not os.path.isfile(aggFile):
helpers.pWarn(
'No aggregate data file exists, running script to obtain from csv file'
)
csvFile = trialFolder + '/' + trialFolder + '.csv'
if not subprocess.call(
[scriptDir + 'get_aggregate_data_from_csv.py', csvFile]) == 0:
for argument in suppliedArguments:
if '--percentile=' in argument:
percentile = float((argument.strip().split('='))[1])
print 'Plotting up to ' + str(percentile) + " percentile"
if '--x_limit=' in argument:
x_limit = float((argument.strip().split('='))[1])
print 'Plotting with x_limit set to ' + str(x_limit)
if '--exclude=' in argument:
exclude_percentage = float((argument.strip().split('='))[1])
print 'excluding the first ' + str(exclude_percentage * 100) + "% data"
if '--save' in argument:
save = True
figureFilePath = helpers.getDir(
input_file) + 'latency_distribution.jpg'
print 'Saving plot to ' + figureFilePath
for input_file in sys.argv[1:]:
bin_analysis.readBinFile(input_file)
sorted_latency_array = np.sort(bin_analysis.getList('latency'))
sorted_latency_list = list(sorted_latency_array)
caring_data_from_id = int(len(sorted_latency_list) * exclude_percentage)
sorted_latency_list = sorted_latency_list[caring_data_from_id:]
yvals_array = np.arange(len(sorted_latency_list)) / float(
len(sorted_latency_list))
yvals_list = list(yvals_array)
if len(sys.argv) < 2:
print "please provide csv file"
exit(1)
csvFile = str(sys.argv[1])
if csvFile.endswith('.csv'):
noSuffix = csvFile[:-4]
else:
noSuffix = csvFile
csvFile = csvFile + '.csv'
if not os.path.isfile(csvFile):
helpers.pErr("Input csv file does not exist")
scriptDir = helpers.getDir(sys.argv[0])
if not os.path.isfile(csvFile + '.correctionLog'):
helpers.pWarn(
'csv correction log does not exist, running correction script')
if not subprocess.call([scriptDir + 'correct_csv.py', csvFile]) == 0:
helpers.pErr('Unable to correct csv file')
setupFile = noSuffix + '.setup'
if not os.path.isfile(setupFile):
print "Cannot find setup file " + setupFile
exit(1)
helpers.readSetup(setupFile)
lsa_cores = helpers.getCores(helpers.params['SERVERCORES'])
Latency95thList = datas[thread]['95thLatency']
# print qpsList
# print Latency95thList
sortedQpsList = []
sortedLatencyList = []
rearrangeByQps(qpsList, Latency95thList, sortedQpsList, sortedLatencyList)
print sortedQpsList
print sortedLatencyList
ax.plot(sortedQpsList,sortedLatencyList,helpers.getBuiltInColor(linesNumber),label='Thread='+thread)
linesNumber += 1
fig.suptitle('95-th Percentile Latency vs. QPS')
ax.set_xlabel('QPS')
ax.set_ylabel('Latency (ms)')
if x_limit > 0:
ax.set_xlim([0, x_limit])
# ax.set_ylim([0 , percentile])
plt.legend()
if save:
figureFilePath = helpers.getDir(input_file)+'latency_distribution.jpg'
print 'Saving plot to ' + figureFilePath
fig.savefig(figureFilePath, dpi=1200)
else:
plt.show()
plt.close(fig)
###############################################################
