plotSpeedupsPyRoot.py

Go to the documentation of this file.

from ROOT import *

'''
Script to parse all the logs and produce the speedup plot.
Usage:
plotSpeedupsPyRoot.py --> vanilla plot
plotSpeedupsPyRoot.py 1 --> HT scaled plot
The variable fname_template contains the template of the file names to be 
opened and parsed and is FIXED for all the logs.
The word "seconds" is looked for in the log and then the total runtime of the 
event loop is extracted. This allows to discard the time spent in calibration 
and so on.
'''

# Configuration ----------------------------------------------------------------
fname_template="measurement_BrunelScenario_n100_eif%s_aif100_nthreads%s_c%s_dqFalse_v5.log"
# Number of events in flight
neif_l=[1,2,3,5,20,30]
# Number of Threads
nts=[2,3,5,10,11,12,13,15,23]
# Clone Flag
cFlags=["True","False"]

ScalarTime=1640.87

#Style
LegendDrawOpts="lp"
LineColours=[kRed,
             kBlue,
             kGreen+2,
             kOrange,
             kPink+10,
             kViolet+10]
MarkerStyles=[kFullCircle,
              kOpenCross,
              kFullTriangleUp,  
              kOpenStar,
              kFullCross,
              kOpenCircle]
MarkerSize=4
LineWidth=6
LineStyle=7
graph_counter=0

PhCores=11
TotalCores=24
HtCoreWeight=0.4

LabelsFont=12
LabelsSize=.6
#--------------------

def scaleCores(n_threads):
   effective_n_threads=n_threads
   if effective_n_threads > PhCores:
      ht_cores = n_threads-PhCores
      effective_n_threads = PhCores + ht_cores * HtCoreWeight
   return effective_n_threads

#--------------------

def getText(x,y,text,scale,angle,colour,font):
    lat = TLatex(x,y,"#scale[%s]{#color[%s]{#font[%s]{%s}}}"%(scale,colour,font,text))
    if angle!=0.:
       lat.SetTextAngle(angle)
    return lat 

#--------------------

def formatGraphs(graph,graphc):
    global graph_counter
    graphc.SetLineStyle(LineStyle)   
    graphs=(graph,graphc)
    for g in graphs:
       g.SetLineWidth(LineWidth)
       g.SetMarkerSize(MarkerSize)
       g.SetMarkerStyle(MarkerStyles[graph_counter])
       g.SetLineColor(LineColours[graph_counter])
       g.SetMarkerColor(LineColours[graph_counter])
    graph_counter+=1

#--------------------

def createFname(neif,nt,cFlag):
  return fname_template %(neif,nt,cFlag)

#--------------------

def xtractTiming(neif,nt,cFlag):
  filename = createFname(neif,nt,cFlag)
  ifile = open(filename,"r")
  seconds=-1
  for line in ifile:
    if "seconds" in line:
      line=line[:-1]
      seconds = float(line.split(" ")[-1])
      break
  ifile.close()
  if seconds==-1:
      seconds=xtractTiming(neif,nts[nts.index(nt)-1],cFlag)
  return seconds

#--------------------

import sys
scaleThreads=False
if len(sys.argv)>1:
    scaleThreads=True
    

# main loop: just printouts
for neif in neif_l:
  print "Events in flight: %s" %neif
  for tn in nts:
    print "%s %s %s" %(tn, xtractTiming(neif,tn,False),xtractTiming(neif,tn,True))

    
len_nt=len(nts)+1
# Prepare ideal speedup graph
idealSpeedup = TGraph(2)
idealSpeedup.SetPoint(0,1,1)
idealSpeedup.SetPoint(1,TotalCores,TotalCores)
scaled_s=""
if scaleThreads:
   scaled_s=" (scaled for HT)"
idealSpeedup.SetTitle("GaudiHive Speedup (Brunel, 100 evts);Thread Pool Size%s;Speedup wrt Serial Case"%scaled_s)
idealSpeedup.SetLineWidth(4)
idealSpeedup.SetLineColor(kGray-2)
idealSpeedup.SetLineStyle(2)
       
# Main Loop: fill all graphs
neif_graphs=[]
for neif in neif_l: # One graph per number of events in flight
   graph = TGraph (len_nt)
   graph.SetName("%s"%neif)
   graph.SetPoint(0,1,1)

   graphc = TGraph (len_nt)
   graphc.SetName("%s clone"%neif)
   graphc.SetPoint(0,1,1)
   counter=1
   for tn in nts:
      scaled_tn=tn
      if scaleThreads:
         scaled_tn=scaleCores(tn)
      time=xtractTiming(neif,tn,False)
      graph.SetPoint(counter,scaled_tn,ScalarTime/time)
      timec=xtractTiming(neif,tn,True)    
      graphc.SetPoint(counter,scaled_tn,ScalarTime/timec)
      counter+=1
   formatGraphs(graph,graphc)
   neif_graphs.append([neif,graph,graphc]) 

neif_graphs.reverse()

# Now that all are complete, let's make the plot
canvas = TCanvas("Speedup","Speedup",2048,1800)
canvas.cd()
canvas.SetGrid()
idealSpeedup.Draw("APL")
idealSpeedup.GetYaxis().SetRangeUser(0.1,TotalCores+1) # only one 0

# Line
line = TLine(11,0,11,25)
line.SetLineColor(kRed)
line.SetLineWidth(4)
line.SetLineStyle(2)
line.Draw()

for neif,graph,graphc in neif_graphs:
    graph.Draw("SamePL")
    graphc.Draw("SamePL")

# Prepare Legend
legend = TLegend(.1,.45,.38,.9)
legend.SetFillColor(kWhite)
legend.SetHeader("# Simultaneous Evts")
for neif,graph,graphc in neif_graphs:
    legend.AddEntry(graph,"%s"%neif,LegendDrawOpts)
    legend.AddEntry(graphc,"%s (clone)"%neif,LegendDrawOpts)
legend.Draw()

# Labels
ph_cores=getText(10.5,15,"Physical Cores",LabelsSize,90,2,LabelsFont)
ph_cores.Draw()
ht_cores=getText(12.,15,"Hardware Threaded Regime",LabelsSize,90,2,LabelsFont)
ht_cores.Draw()
is_text=getText(16,16.5,"Ideal (linear) Speedup", LabelsSize, 45, 918, LabelsFont)
is_text.Draw()
ht_weight=0
if scaleThreads:
   ht_weight=getText(18.5,8,"#splitline{Hardware threaded}{cores weight: %s}"%HtCoreWeight,LabelsSize,0,600,LabelsFont)
   ht_weight.Draw()

if scaleThreads:
   scaled_s="_HTScaled"
canvas.Print("GaudiHivePerfBrunelAllPoints%s.png"%scaled_s)