Benchmarking & Scaling Tutorial/Results - Revision history

Christian-siebert-cbc6@uni-duesseldorf.de: spelling mistake corrected

2022-09-08T08:31:30Z

spelling mistake corrected

Sebastian-potthoff-3c73@uni-muenster.de at 11:00, 11 March 2022

2022-03-11T11:00:11Z

Sebastian-potthoff-3c73@uni-muenster.de at 10:14, 11 March 2022

2022-03-11T10:14:13Z

Sebastian-potthoff-3c73@uni-muenster.de at 10:08, 11 March 2022

2022-03-11T10:08:12Z

Sebastian-potthoff-3c73@uni-muenster.de at 09:26, 11 March 2022

2022-03-11T09:26:03Z

Sebastian-potthoff-3c73@uni-muenster.de: Created page with "{{DISPLAYTITLE:Plotting and Interpreting Results}} {{Syllabus Benchmarking & Scaling}} TOC == Plotting results == We can write a simple Python script..."

2022-03-11T09:02:16Z

Created page with "{{DISPLAYTITLE:Plotting and Interpreting Results}}<nowiki /> {{Syllabus Benchmarking & Scaling}}<nowiki /> __TOC__ == Plotting results == We can write a simple Python script..."

New page

{{DISPLAYTITLE:Plotting and Interpreting Results}}<nowiki />
{{Syllabus Benchmarking & Scaling}}<nowiki />
__TOC__

== Plotting results ==

We can write a simple Python script to process and plot the resulting data. For this purpose we are making use of the numpy and matplotlib Python libraries.

<syntaxhighlight lang="python">
#!/usr/bin/env python3

import numpy as np
import matplotlib.pyplot as plt

data = np.loadtxt("results_weak_scaling.dat")

# Different set every 10 data points (5 serial + 5 parallel)
wat05 = data[0:10]
wat10 = data[10:20]
wat15 = data[20:30]

wat = [wat05, wat10, wat15]

# Calculate the mean times for every set
stimes = []
ptimes = []
for d in wat:
stimes.append(np.mean(d[0:5], axis=0))
ptimes.append(np.mean(d[5:10], axis=0))

# Re-transform to numpy array
stimes = np.asarray(stimes)
ptimes = np.asarray(ptimes)

# Calculate speedup
speedup = stimes[:,1]/ptimes[:,1]

# Get the No of processors
nprocs = ptimes[:,0]

# Plot
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(nprocs, speedup, '--o', label="speedup")
ax.plot(nprocs, nprocs, '--', color='gray', label="ideal")
ax.legend()
ax.set_xlabel("processors")
ax.set_ylabel("speedup")
ax.set_title("weak scaling")
for x,y,label in zip(nprocs, speedup,["5NM","10NM","15NM"]):
ax.annotate(label, xy=(x,y), textcoords="offset points", xytext=(-12,10))

</syntaxhighlight>

----

'''Previous''': [[Benchmarking_%26_Scaling_Tutorial/Automated_Benchmarking | Automated Benchmarking using a Job Script ]]

@@ Line 39: / Line 39: @@
 </syntaxhighlight>
-In the plot below, you can see the results for the small 5NM system with and without enabled hyper-threading as well as the theoretical behavior for a code with a serial fraction of around 2%. The first thing we notice, is that the simulation does not benefit from using hyper-threading - even worse, the performance degrades. This does, however, not mean that this is always the case. Some codes can actually benefit from using it. The comparison to the theoretical curve with F=2%, tells us that the GROMACS code if fairly well parallelized. We can also observe, that there is no substantial gain in speedup after using more than 24 cores for this system. So when creating a production job with this system, we would limit the number of cores to 24 to not waste any resources.
+In the plot below, you can see the results for the small 5NM system with and without enabled hyper-threading as well as the theoretical behavior for a code with a serial fraction of around 2%. The first thing we notice, is that the simulation does not benefit from using hyper-threading - even worse, the performance degrades. This does, however, not mean that this is always the case. Some codes can actually benefit from using it. The comparison to the theoretical curve with F=2%, tells us that the GROMACS code is fairly well parallelized. We can also observe, that there is no substantial gain in speedup after using more than 24 cores for this system. So when creating a production job with this system, we would limit the number of cores to 24 to not waste any resources.
 [[File:Strong_scaling_5nm_example.png|600px]]

@@ Line 3: / Line 3: @@
 __TOC__
-== Weak scaling ==
+== Strong Scaling ==
 The results for the weak scaling example were obtained by running the simulation for the 5NM, 10NM and 15NM systems using using 9, 18 and 36 cores, respectively. A serial run with one core for each system was performed as a reference. Each run was repeated five times. The bash/job script can be found below:
@@ Line 87: / Line 127: @@
 </syntaxhighlight>
+We can again write a simple Python script to process and plot the resulting data.
 <div class="toccolours mw-collapsible mw-collapsed">

@@ Line 137: / Line 137: @@
 for x,y,label in zip(nprocs, speedup,["5NM","10NM","15NM"]):
      ax.annotate(label, xy=(x,y), textcoords="offset points", xytext=(-12,10))
 </syntaxhighlight>
@@ Line 143: / Line 145: @@
 </div>
 ----
 '''Previous''': [[Benchmarking_%26_Scaling_Tutorial/Automated_Benchmarking | Automated Benchmarking using a Job Script ]]

@@ Line 5: / Line 5: @@
 == Weak scaling ==
-We can write a simple Python script to process and plot the resulting data. For this purpose we are making use of the numpy and matplotlib Python libraries.
+The results for the weak scaling example were obtained by running the simulation for the 5NM, 10NM and 15NM systems using using 9, 18 and 36 cores, respectively. A serial run with one core for each system was performed as a reference. Each run was repeated five times. The bash/job script can be found below:
 <syntaxhighlight lang="python">
 #!/usr/bin/env python3
@@ Line 53: / Line 139: @@
 </syntaxhighlight>
-}}
 ----
 '''Previous''': [[Benchmarking_%26_Scaling_Tutorial/Automated_Benchmarking | Automated Benchmarking using a Job Script ]]