HPC/Benchmarks/Generation 1 vs 2
Introduction
In early 2010, we received 200 additional nodes with two E5540 processors each. The processors have 4 cores each, and support hyperthreading, a feature which allows 2 threads per core. This benchmark investigates the benefit of hyperthreading (HT), and suggests optimal values for the nodes and ppn (processors per node) parameters in PBS. The choice is not trivial and involves tradeoffs between various metrics such as execution time or compute-hours charged.
Test description
This test runs /opt/soft/vasp-4.6.35-mkl-8/bin/vasp.
- Full input data (Credit: D. Shin, Northwestern University).
Explanation of data columns
Parameters
- cores/app
- The number of cores that a single application workload is executed on. Typically, this value is used in studies of the parallel scaling (parallelization efficiency) of an application.
- napps
- The number of applications run in parallel within the job. Typically, a user will run only one (MPI) application at a time. This benchmark allows to run more than one application in parallel, equally subdividing the available cores on any participant node via the OpenMPI
--npernode nflag. Motivation: As a hypothesis, I considered it possible to be beneficial to run several (related or unrelated) applications on a processor, but not within the same MPI job. Different workloads would minimize the chance of congestion of the processors' pipelining architecture. - gen
- The node hardware generation
- gen1 = Intel Xeon X5355, 2.66GHz, 8 cores per node, 16 GB RAM per node (2 GB/core)
- gen2 = Intel Xeon E5540, 2.53GHz, 8 cores per node, 24 GB RAM per node (3 GB/core), hyperthreading enabled in hardware (BIOS)
- nodes
- Number of nodes requested from the queing system.
- ppn
- Processors per node requested from the queing system.
Objective variables
- tmax → min
- The wallclock runtime of a job in seconds. When multiple applications are run, the longest runtime is used. This is the time metric used for calculating the job charge.
- charge → min
- The charge for the job, expressed in core-hours per application. Since the present test may use more than one application in a job, the value is normalized by the number of applications run within the job. This reflects the situation that the user will be interested in getting things done for minimal charge.
- Note: In the near future, a charge factor will be introduced for gen2 nodes which will scale actual node-hours to effective node hours, in a manner that levels the performance difference between the node generations. At present, no charge factor is applied.
- combined objective tmax × charge → min
- An empirical objective to minimize both time and charge. Since the charge is proportional to time, the time effectively enters quadratically.
- perf → max
- A measure for the performance per core. It should be proportional to the FLoating point Operations Per Second (FLOPS) achieved. Since the actual number of operations for the chosen workload is unknown, the value here is calculated using an arbitrary constant to produce convenient values:
perf := 100000 * napps / tmax / charge_cores
Miscellaneous
- run
- a sequence number, used to identify the run and its various files and directories.
- charge_cores
- the number of cores requested from the queing system, i.e., those blocked from use by other users. The tests within the benchmark ran with the qsub option (lowercase "ell")
-l naccesspolicy=singlejob. - HT
- hyperthreading is in effect for this run
Results
Data
Files
- Raw data, grep-able
- Raw data, tab-separated CSV
- Analysis (PDF), with comparisons made by tmax, charge, and both. The last page contains a direct comparison of the performance of gen1 vs. gen2 nodes.
Gen1 nodes
| cores/app |
run |
nodes |
ppn |
napps |
tmax |
charge- cores |
charge raw (core-h/app) |
perf (ops/s/core) |
combined objective |
HT |
|---|---|---|---|---|---|---|---|---|---|---|
| 4 | 1 | 1 | 4 | 1 | 1138.83 | 8 | 2.53 | 11.0 | 28.82 | |
| 4 | 3 | 1 | 8 | 2 | 2488.86 | 8 | 2.77 | 10.0 | 68.83 | |
| 6 | 11 | 1 | 6 | 1 | 1566.07 | 8 | 3.48 | 8.0 | 54.50 | |
| 6 | 13 | 2 | 3 | 1 | 816.61 | 16 | 3.63 | 7.7 | 29.64 | |
| 6 | 16 | 2 | 6 | 2 | 1401.48 | 16 | 3.11 | 8.9 | 43.65 | |
| 8 | 21 | 1 | 8 | 1 | 1488.72 | 8 | 3.31 | 8.4 | 49.25 | |
| 8 | 23 | 2 | 4 | 1 | 791.37 | 16 | 3.52 | 7.9 | 27.83 | |
| 8 | 26 | 2 | 8 | 2 | 1494.81 | 16 | 3.32 | 8.4 | 49.65 | |
| 12 | 31 | 2 | 6 | 1 | 838.08 | 16 | 3.72 | 7.5 | 31.22 | |
| 12 | 33 | 3 | 4 | 1 | 544.74 | 24 | 3.63 | 7.6 | 19.78 | |
| 12 | 35 | 4 | 3 | 1 | 503.05 | 32 | 4.47 | 6.2 | 22.49 | |
| 12 | 41 | 3 | 8 | 2 | 1117.20 | 24 | 3.72 | 7.5 | 41.60 | |
| 12 | 43 | 4 | 6 | 2 | 838.51 | 32 | 3.73 | 7.5 | 31.25 | |
| 16 | 51 | 2 | 8 | 1 | 998.73 | 16 | 4.44 | 6.3 | 44.33 | |
| 16 | 53 | 4 | 4 | 1 | 522.50 | 32 | 4.64 | 6.0 | 24.27 | |
| 16 | 56 | 4 | 8 | 2 | 1626.13 | 32 | 7.23 | 3.8 | 117.52 |
Gen2 nodes
| cores/app |
run |
nodes |
ppn |
napps |
tmax |
charge- cores |
charge raw (core-h/app) |
perf (ops/s/core) |
combined objective |
HT |
|---|---|---|---|---|---|---|---|---|---|---|
| 4 | 2 | 1 | 4 | 1 | 516.69 | 8 | 1.15 | 24.2 | 5.93 | |
| 4 | 4 | 1 | 8 | 2 | 767.26 | 8 | 0.85 | 32.6 | 6.54 | |
| 6 | 12 | 1 | 6 | 1 | 470.10 | 8 | 1.04 | 26.6 | 4.91 | |
| 6 | 14 | 2 | 3 | 1 | 447.01 | 16 | 1.99 | 14.0 | 8.88 | |
| 6 | 15 | 1 | 12 | 2 | 867.12 | 8 | 0.96 | 28.8 | 8.35 | HT |
| 6 | 17 | 2 | 6 | 2 | 587.55 | 16 | 1.31 | 21.3 | 7.67 | |
| 8 | 22 | 1 | 8 | 1 | 472.16 | 8 | 1.05 | 26.5 | 4.95 | |
| 8 | 24 | 2 | 4 | 1 | 426.55 | 16 | 1.90 | 14.7 | 8.09 | |
| 8 | 25 | 1 | 16 | 2 | 927.22 | 8 | 1.03 | 27.0 | 9.55 | HT |
| 8 | 27 | 2 | 8 | 2 | 596.30 | 16 | 1.33 | 21.0 | 7.90 | |
| 12 | 30 | 1 | 12 | 1 | 565.44 | 8 | 1.26 | 22.1 | 7.10 | HT |
| 12 | 32 | 2 | 6 | 1 | 330.88 | 16 | 1.47 | 18.9 | 4.87 | |
| 12 | 34 | 3 | 4 | 1 | 270.06 | 24 | 1.80 | 15.4 | 4.86 | |
| 12 | 36 | 4 | 3 | 1 | 267.81 | 32 | 2.38 | 11.7 | 6.38 | |
| 12 | 40 | 2 | 12 | 2 | 582.08 | 16 | 1.29 | 21.5 | 7.53 | HT |
| 12 | 42 | 3 | 8 | 2 | 383.44 | 24 | 1.28 | 21.7 | 4.90 | |
| 12 | 44 | 4 | 6 | 2 | 321.16 | 32 | 1.43 | 19.5 | 4.58 | |
| 16 | 50 | 1 | 16 | 1 | 592.26 | 8 | 1.32 | 21.1 | 7.79 | HT |
| 16 | 52 | 2 | 8 | 1 | 329.10 | 16 | 1.46 | 19.0 | 4.81 | |
| 16 | 54 | 4 | 4 | 1 | 237.59 | 32 | 2.11 | 13.2 | 5.02 | |
| 16 | 55 | 2 | 16 | 2 | 601.78 | 16 | 1.34 | 20.8 | 8.05 | HT |
| 16 | 57 | 4 | 8 | 2 | 327.90 | 32 | 1.46 | 19.1 | 4.78 |
Observations
- For the same core constellation in a workload, gen2 nodes are 2...3 times faster than gen1 nodes – see last page in the analysis (PDF).
- 4-core runs give the highest numerical throughput in each node type (run=01 to 04).
- gen2 nodes are fine for VASP with nodes=1:ppn=8; gen1 nodes are not (run=22 vs. 21).
Hyperthreading and node-sharing
- Naïve application of hyperthreading (HT) is detrimental - it leads to increased runtimes and thus increased charges.
- run=50 (ppn=16), charge 26% higher than run=22 (ppn=8)
- run=30 (ppn=12), charge 20% higher than run=22 (ppn=8)
- However, when non-MPI jobs or two unsynced MPI jobs are running (run=15, 25, 17), HT yields 10...20% lower charge rates. This is a pittance and makes HT largely unattractive. Unsynced MPI jobs (i.e., sharing nodes) is mildly beneficial in all cases, whether hyperthreading is used or not (runs=04, 15, 25; see pg. 4 in the PDF. The best-case scenario gives a charge savings of -24% (run=15 vs. 30, at nodes=1:ppn=12). This is even the case on gen1 nodes (e.g., runs=26 vs. 51, at nodes=2:ppn=8, charge savings = -25%).
- Running two apps in a single job is mostly not worth the effort of managing them.
- Sharing nodes confers a mild benefit and should be rewarded in a charge discount.
Recommendations
For the given workload, the following values for optimal performance with respect to the given objective can be recommended:
| Node type | Objective | ||
|---|---|---|---|
| time → min | charge → min | time × charge → min | |
| gen1 | nodes=4:ppn=3:gen1 |
nodes=1:ppn=4:gen1 |
nodes=3:ppn=4:gen1
|
| run=35 tmax=503.05 charge=4.47 |
run=01 tmax=1138.83 charge=2.53 |
run=33 tmax=544.74 charge=3.63 | |
| gen2 | nodes=4:ppn=4:gen2 |
nodes=1:ppn=8:gen2 |
nodes=2:ppn=8:gen2
|
| run=54 tmax=237.59 charge=2.11 |
run=22 tmax=472.16 charge=1.05 |
run=52 tmax=329.10 charge=1.46 | |
The last column is an empirically formulated objective to minimize both time and charge. Compared to the minimum-charge runs (Objective columns 2, runs 01 and 22, respectively), adding nodes will reduce the runtime and only slighty increase the charge. The fastest runs (first Objective column) use the same number of cores for calculation, but since the number of nodes is higher, so is charge_cores, and thus the job charge is also higher.
Update
Adjusting VASP input
The VASP manual recommends NPAR to number of nodes (understood to be number of cores, since at the time single-core CPUs were all the rage). Nowadays, it would be better to set
NPAR = number of nodes
meaning the number of SMP nodes, which is the current state of the art.
(Credit: M. Chan).
Charge rates
Given the above benchmark results, the charge rate on gen1 nodes was set to 0.5 early on (soon after the gen2 nodes were put into production). This means that a task will incur approximately the same charge when run on either gen1 or gen2 nodes. Short tasks even have a certain advantage to run on gen1 nodes, since often the wait time there is lower, while the longer execution time matters less for the user (being small to begin with).
Charges in the benchmark above are raw, without this factor, i.e, charge cores wall time, where charge cores is the number of cores reserved by Moab.
--stern