Performances - Revision history

Lartigue: /* Methodology */

2021-04-01T15:20:07Z

‎Methodology

Abdelsamie at 14:44, 1 October 2020

2020-10-01T14:44:27Z

Abdelsamie: /* TauBench performance benchmark */

2020-10-01T14:33:21Z

‎TauBench performance benchmark

Abdelsamie at 14:32, 1 October 2020

2020-10-01T14:32:21Z

Abdelsamie at 21:11, 26 September 2020

2020-09-26T21:11:44Z

Abdelsamie at 21:07, 26 September 2020

2020-09-26T21:07:36Z

Abdelsamie at 18:09, 26 September 2020

2020-09-26T18:09:21Z

Abdelsamie: /* Irene Joliot-Curie from TGCC */

2020-09-26T18:07:32Z

‎Irene Joliot-Curie from TGCC

Abdelsamie at 18:05, 26 September 2020

2020-09-26T18:05:14Z

Abdelsamie: Created page with "The results presented above were obtained on different architectures, preventing the direct comparison of the performance of the codes. However, the TauBench pseudo-benchmark~..."

2020-09-26T18:02:37Z

Created page with "The results presented above were obtained on different architectures, preventing the direct comparison of the performance of the codes. However, the TauBench pseudo-benchmark~..."

New page

The results presented above were obtained on different architectures, preventing the direct comparison of the performance of the codes.
However, the TauBench pseudo-benchmark~\cite{TauBench,TauBench2} made it possible to assess in a separate test the raw performance of each machine.
The following sections will describe the configuration of the three high performance
computing (HPC) systems that were used to run YALES2, DINO and Nek5000 for the TGV benchmarks.
Subsequently, the TauBench methodology and its results on the target computers will be presented.
Finally, the performance analysis for the 3-D TGV cases is discussed in the last subsection.

'''Presentation of the machines used for the benchmark
'''[[Irene Joliot-Curie from TGCC]]

@@ Line 85: / Line 85: @@
 <math>
-RTC = \frac{TCPU}{Nit \times N_p}
+RCT = \frac{TCPU}{Nit \times N_p}
 </math>

← Older revision		Revision as of 14:44, 1 October 2020
Line 78:		Line 78:

	This table presents some important data of the three considered HPC systems: the processor frequency, the result ofTauBench, the theoretical peak performance and the memory bandwidth. The last three results are given for a singlecore. The most striking – though not unexpected – conclusion is that TauBench provides results that are much lowerthan the theoretical peak performance (3% of the peak for Irene Joliot-Curie and for SuperMUC-NG, and 12% forPitz Daint). This is in agreement with the results from the similar and well-known benchmark HPCG [86] that is alsointended as a complement to the High Performance LINPACK (HPL) benchmark, currently used to rank the Top500computing systems. For example, the HPCG benchmark on the Irene Joliot-Curie revealed a peak performanceof 0.66 GFlop/s per core [87], which is approximately only 0.8% of the peak performance. The main reason forthe discrepancy between the LINPACK and the HPCG benchmark is that the first one is purely CPU-bound whileHPCG is mostly limited by the memory bandwidth and cache-miss effects. TauBench is somewhere in between andis probably a good estimate for many CFD codes.Indeed, the theoretical peak performance can only be reached when performing 2 fully-vectorized Fused Multiply-Add (FMA) instructions per cycle. This situation is never achieved in any CFD code. Most of them are usuallylimited to issuing only one non-vectorized non-FMA instruction per cycle; in this situation, the peak performance (inGFlop/s) is simply equal to the processor frequency (in GHz). This can be observed very clearly on SuperMUC andIrene Joliot-Curie. Regarding the Pitz Daint machine, it appears that the TauBench result is actually much betterthere than on the two other machines when compared to theoretical peak performance; this is somewhat unexpectedand might be due to the use of TurboBoost on this machine, or to a better memory/cache performance.It should be pointed out that no effort was made to find the best parameters (tolerances, timestep, etc.) tominimize the computational cost, and the following results should only be considered as indicative of the time-to-solution of the three codes.		This table presents some important data of the three considered HPC systems: the processor frequency, the result ofTauBench, the theoretical peak performance and the memory bandwidth. The last three results are given for a singlecore. The most striking – though not unexpected – conclusion is that TauBench provides results that are much lowerthan the theoretical peak performance (3% of the peak for Irene Joliot-Curie and for SuperMUC-NG, and 12% forPitz Daint). This is in agreement with the results from the similar and well-known benchmark HPCG [86] that is alsointended as a complement to the High Performance LINPACK (HPL) benchmark, currently used to rank the Top500computing systems. For example, the HPCG benchmark on the Irene Joliot-Curie revealed a peak performanceof 0.66 GFlop/s per core [87], which is approximately only 0.8% of the peak performance. The main reason forthe discrepancy between the LINPACK and the HPCG benchmark is that the first one is purely CPU-bound whileHPCG is mostly limited by the memory bandwidth and cache-miss effects. TauBench is somewhere in between andis probably a good estimate for many CFD codes.Indeed, the theoretical peak performance can only be reached when performing 2 fully-vectorized Fused Multiply-Add (FMA) instructions per cycle. This situation is never achieved in any CFD code. Most of them are usuallylimited to issuing only one non-vectorized non-FMA instruction per cycle; in this situation, the peak performance (inGFlop/s) is simply equal to the processor frequency (in GHz). This can be observed very clearly on SuperMUC andIrene Joliot-Curie. Regarding the Pitz Daint machine, it appears that the TauBench result is actually much betterthere than on the two other machines when compared to theoretical peak performance; this is somewhat unexpectedand might be due to the use of TurboBoost on this machine, or to a better memory/cache performance.It should be pointed out that no effort was made to find the best parameters (tolerances, timestep, etc.) tominimize the computational cost, and the following results should only be considered as indicative of the time-to-solution of the three codes.
		+
		+	= Methodology =
		+	Several metrics will be used in the following sections to characterize the codes. They are introduced by givingboth a formal definition as well as a few complementary explanations. In order to avoid any confusion between CPUtime and Simulated time, the corresponding data will be indexed by <sub>CPU</sub> and <sub>Sim</sub>, respectively.
		+
		+	First, the Wall-Clock Time (WCT) is the elapsed time to perform a simulation on a given number of cores Ncores.The product TCPU = Ncores×WCT is thus the total CPU time for the simulation.A more meaningful metric is the so-called Reduced Computational Time (RCT), which is computed as:
		+
		+	<math>
		+	RTC = \frac{TCPU}{Nit \times N_p}
		+	</math>

← Older revision		Revision as of 14:33, 1 October 2020
Line 76:		Line 76:
	\| 19.2		\| 19.2
	\|}		\|}
		+
		+	This table presents some important data of the three considered HPC systems: the processor frequency, the result ofTauBench, the theoretical peak performance and the memory bandwidth. The last three results are given for a singlecore. The most striking – though not unexpected – conclusion is that TauBench provides results that are much lowerthan the theoretical peak performance (3% of the peak for Irene Joliot-Curie and for SuperMUC-NG, and 12% forPitz Daint). This is in agreement with the results from the similar and well-known benchmark HPCG [86] that is alsointended as a complement to the High Performance LINPACK (HPL) benchmark, currently used to rank the Top500computing systems. For example, the HPCG benchmark on the Irene Joliot-Curie revealed a peak performanceof 0.66 GFlop/s per core [87], which is approximately only 0.8% of the peak performance. The main reason forthe discrepancy between the LINPACK and the HPCG benchmark is that the first one is purely CPU-bound whileHPCG is mostly limited by the memory bandwidth and cache-miss effects. TauBench is somewhere in between andis probably a good estimate for many CFD codes.Indeed, the theoretical peak performance can only be reached when performing 2 fully-vectorized Fused Multiply-Add (FMA) instructions per cycle. This situation is never achieved in any CFD code. Most of them are usuallylimited to issuing only one non-vectorized non-FMA instruction per cycle; in this situation, the peak performance (inGFlop/s) is simply equal to the processor frequency (in GHz). This can be observed very clearly on SuperMUC andIrene Joliot-Curie. Regarding the Pitz Daint machine, it appears that the TauBench result is actually much betterthere than on the two other machines when compared to theoretical peak performance; this is somewhat unexpectedand might be due to the use of TurboBoost on this machine, or to a better memory/cache performance.It should be pointed out that no effort was made to find the best parameters (tolerances, timestep, etc.) tominimize the computational cost, and the following results should only be considered as indicative of the time-to-solution of the three codes.

← Older revision		Revision as of 14:32, 1 October 2020
Line 46:		Line 46:
	It is used to provide a reference measurement of a system on a workload that is more representative of usual CFD codes than the widely used LINPACK benchmark~\cite{linpack}, which is mostly CPU-bound.		It is used to provide a reference measurement of a system on a workload that is more representative of usual CFD codes than the widely used LINPACK benchmark~\cite{linpack}, which is mostly CPU-bound.
	Even though some important effects are neglected by using a single-core benchmark (like MPI communications or memory bandwidth saturation that appear on fully-filled nodes), TauBench is still a good indicator of the relative performance of each architecture.		Even though some important effects are neglected by using a single-core benchmark (like MPI communications or memory bandwidth saturation that appear on fully-filled nodes), TauBench is still a good indicator of the relative performance of each architecture.
		+
		+
		+	{\| class="wikitable alternance center"
		+	\|+ Single-core performance obtained by TauBench for the three HPC systems employed in the benchmarks
		+	\|-
		+	! scope="col" \| Machine
		+	! scope="col" \| Irene Joliot-Curie
		+	! scope="col" \| SuperMuc-NG
		+	! scope="col" \| Pitz Daint
		+	\|-
		+	! scope="row" \| Frequency [GHz]
		+	\| 2.7
		+	\| 3.1
		+	\| 2.1
		+	\|-
		+	! scope="row" \| Single core TauBench [GFlop/s]
		+	\| 2.97
		+	\| 3.34
		+	\| 4.13
		+	\|-
		+	! scope="row" \| Single core Peak [GFlop/s]
		+	\| 86.4
		+	\| 99.2
		+	\| 33.6
		+	\|-
		+	! scope="row" \| Single core BW [GB/s]
		+	\| 21.3
		+	\| 21.3
		+	\| 19.2
		+	\|}

@@ Line 6: / Line 6: @@
 Finally, the performance analysis for the 3-D TGV cases is discussed in the last subsection.
-The results of the Benchmark are organized as follows:
+== Irene Joliot-Curie from TGCC ==
-= Yales2 =
+The YALES2 results were obtained on the Irene Joliot-Curie machine~\cite{irene} operated by TGCC/CEA for GENCI (French National Agency for Supercomputing).
-== Step 1 ==
+== SuperMUC-NG from LRZ ==
-This is a link to get the file [[File:Step11b_Ux_vs_x_10.0s_CORIA_YALES2.txt]].
+All test cases with DINO were simulated on the SuperMUC machine, hosted at the Leibniz Supercomputing Center (LRZ) in Munich, Germany~\cite{supermuc}.
-This is a link to get the file [[File:Step11b_Uy_vs_y_10.0s_CORIA_YALES2.txt]].
+== Piz Daint from CSCS ==
-== Step 2 ==
+The Nek5000 simulations were performed on the XC40 partition of the Piz Daint machine at CSCS in Switzerland~\cite{pizdaint}.
-This is a link to get the file [[File:Step2 YALES2 512 CFL0.20.txt]].
+= TauBench performance benchmark =
-This is a link to get the file [[File:Step2 YALES2 512 CFL0.30.txt]].
+The scalable benchmark TauBench emulates the run time behavior of the compressible TAU flow solver~\cite{dlr22421} with respect to the memory footprint and floating-point performance.
+Since the TAU solver relies on unstructured grids, its most important property is that all access points to the grid are indirect, as in most modern CFD solvers.
-This is a link to get the file [[File:Step2 YALES2 512 CFL0.60.txt]].
+TauBench can therefore be used to estimate the performance of a generic flow solver with respect to machine properties, like memory bandwidth or cache miss/latencies.
+It is used to provide a reference measurement of a system on a workload that is more representative of usual CFD codes than the widely used LINPACK benchmark~\cite{linpack}, which is mostly CPU-bound.
-This is a link to get the file [[File:Step12a_description_CORIA_YALES2.txt]].
+Even though some important effects are neglected by using a single-core benchmark (like MPI communications or memory bandwidth saturation that appear on fully-filled nodes), TauBench is still a good indicator of the relative performance of each architecture.
-−
-This is a link to get the file [[File:Step12b_12.11s_Ux_vs_x_CORIA_YALES2.txt]].
-−
-This is a link to get the file [[File:Step12b_12.11s_Uy_vs_y_CORIA_YALES2.txt]].
-−
-This is a link to get the file [[File:Step12b_12.11s_Wz_vs_x_CORIA_YALES2.txt]].
-−
-This is a link to get the file [[File:Step12b_EPS_vs_t_CORIA_YALES2.txt]].
-−
-This is a link to get the file [[File:Step12b_KE_vs_t_CORIA_YALES2.txt]].
-−
-This is a link to get the file [[File:Step12c_scaling_CORIA_YALES2.txt]].
-−
-This is a link to get the file [[File:Step12d_PressureConvergence_CORIA_YALES2.txt]].
-−
-== Step 3 ==

@@ Line 7: / Line 7: @@
 = Presentation of the machines used for the benchmark =
 == [[Irene Joliot-Curie from TGCC]] ==
 The YALES2 results were obtained on the Irene Joliot-Curie machine~\cite{irene} operated by TGCC/CEA for GENCI (French National Agency for Supercomputing).
 %This machine built by Atos was introduced in Sept. 2018 and is ranked at the 61th position of June 2020 Top500 ranking~\cite{ireneTop500}.

← Older revision		Revision as of 18:07, 26 September 2020
Line 8:		Line 8:
	= Presentation of the machines used for the benchmark =		= Presentation of the machines used for the benchmark =
	== [[Irene Joliot-Curie from TGCC]] ==		== [[Irene Joliot-Curie from TGCC]] ==
		+	The YALES2 results were obtained on the Irene Joliot-Curie machine~\cite{irene} operated by TGCC/CEA for GENCI (French National Agency for Supercomputing).
		+	%This machine built by Atos was introduced in Sept. 2018 and is ranked at the 61th position of June 2020 Top500 ranking~\cite{ireneTop500}.
		+	It is composed of 1,656 compute nodes, with 192 GB memory on each node and two sockets of Intel Skylake (Xeon Platinum 8168) with 24 cores each, operating at 2.7 GHz.
		+	Each core can deliver a theoretical peak performance of 86.4 GFlop/s with AVX-512 and FMA activated.
		+	The interconnect is an Infiniband EDR, and the theoretical maximum bandwidth is 128 GB/s per socket and thus 5.33 GB/s by core when all cores are active.
		+	The software stack consists of the Intel Compiler 19 and OpenMPI 2.0.4, both used for all results obtained in this benchmark.