plotSpeedupsPyRoot.py

Go to the documentation of this file.

import ROOT
 
"""
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 = [
    ROOT.kRed,
    ROOT.kBlue,
    ROOT.kGreen + 2,
    ROOT.kOrange,
    ROOT.kPink + 10,
    ROOT.kViolet + 10,
]
MarkerStyles = [
    ROOT.kFullCircle,
    ROOT.kOpenCross,
    ROOT.kFullTriangleUp,
    ROOT.kOpenStar,
    ROOT.kFullCross,
    ROOT.kOpenCircle,
]
MarkerSize = 4
LineWidth = 6
LineStyle = 7
graph_counter = 0
 
PhCores = 11
TotalCores = 24
HtCoreWeight = 0.4
 
LabelsFont = 12
LabelsSize = 0.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 = ROOT.TLatex(
        x, y, f"#scale[{scale}]{{#color[{colour}]{{#font[{font}]{{{text}}}}}}}"
    )
    if angle != 0.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)
    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(f"Events in flight: {neif}")
    for tn in nts:
        print(f"{tn} {xtractTiming(neif, tn, False)} {xtractTiming(neif, tn, True)}")
 
len_nt = len(nts) + 1
# Prepare ideal speedup graph
idealSpeedup = ROOT.TGraph(2)
idealSpeedup.SetPoint(0, 1, 1)
idealSpeedup.SetPoint(1, TotalCores, TotalCores)
scaled_s = ""
if scaleThreads:
    scaled_s = " (scaled for HT)"
idealSpeedup.SetTitle(
    f"GaudiHive Speedup (Brunel, 100 evts);Thread Pool Size{scaled_s};Speedup wrt Serial Case"
)
idealSpeedup.SetLineWidth(4)
idealSpeedup.SetLineColor(ROOT.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 = ROOT.TGraph(len_nt)
    graph.SetName(f"{neif}")
    graph.SetPoint(0, 1, 1)
 
    graphc = ROOT.TGraph(len_nt)
    graphc.SetName(f"{neif} clone")
    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 = ROOT.TCanvas("Speedup", "Speedup", 2048, 1800)
canvas.cd()
canvas.SetGrid()
idealSpeedup.Draw("APL")
idealSpeedup.GetYaxis().SetRangeUser(0.1, TotalCores + 1)  # only one 0
 
# Line
line = ROOT.TLine(11, 0, 11, 25)
line.SetLineColor(ROOT.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 = ROOT.TLegend(0.1, 0.45, 0.38, 0.9)
legend.SetFillColor(ROOT.kWhite)
legend.SetHeader("# Simultaneous Evts")
for neif, graph, graphc in neif_graphs:
    legend.AddEntry(graph, f"{neif}", LegendDrawOpts)
    legend.AddEntry(graphc, f"{neif} (clone)", LegendDrawOpts)
legend.Draw()
 
# Labels
ph_cores = getText(10.5, 15, "Physical Cores", LabelsSize, 90, 2, LabelsFont)
ph_cores.Draw()
ht_cores = getText(12.0, 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,
        f"#splitline{{Hardware threaded}}{{cores weight: {HtCoreWeight}}}",
        LabelsSize,
        0,
        600,
        LabelsFont,
    )
    ht_weight.Draw()
 
if scaleThreads:
    scaled_s = "_HTScaled"
canvas.Print(f"GaudiHivePerfBrunelAllPoints{scaled_s}.png")