## 5 Experiments
### Analysis of the Results
The results are shown in Table 8.  
\begin{table}
\begin{tabular}{c c c c c c c c c c c c} \hline \hline \multirow{2}{*}{**(CP)**} & \multicolumn{4}{c}{**DAC**} & \multicolumn{4}{c}{**MasterSlave**} & \multicolumn{4}{c}{**SPMD**} \\ \cline{2-11}  & **(A)** & **(B)** & **(C)** & **(S\({}_{\mu}\  
**(CP)**: Computing processes  
Argument _param_ in functions (2) and (3) (\(d\) and \(h\)) means the best compilation parameter for program (from Table 6). It is used to explain values in columns **(A), (B), (C)** and **(S\({}_{I}\))**. **(A)**: Difference between execution time on Docker and Host with the selected compilation flag  
\[a(param,prog,proc)=|d(param,prog,proc)-h(param,prog,proc)|[\text{s}] \tag{8}\]
**(B)**: Faster runtime machine (D--Docker, H--Host). \[b(param,prog,proc)= \begin{cases}D,&\text{if }d(param,prog,proc)<h(param,prog, proc)\\ H,&\text{if }d(param,prog,proc)>h(param,prog,proc)\end{cases}  \tag{9}\]
**(C)**: Answer to question: \"How many percent the Docker is faster (if column (B) equals \(D\)) or slower (if column (B) equals \(H\)) than Host\". For example--DAC program and 32 computing processes: Docker (because H is present in column (B)) is 0.97% slower than Host. Values from this column are presented in Figure 14.  
\[c(param,prog,proc)=\left|1-\frac{d(param,prog,proc)}{h(param,prog,proc)} \right|\times 100\% \tag{10}\]
**(S\({}_{I}\))**: Factor of speed-up indicator for Docker and Host. \[S_{f}(param,prog,proc)=\frac{speedup(Docker,param,prog,proc)}{speedup(Host, param,prog,proc)} \tag{11}\]  
As we can see for all the applications, up to 32 computing processes, it does not practically matter whether these programs are run on the Host or Docker and differences between machines (**(C)** column) are smaller than 1%. Using 64 computing processes (highlighted) and more, all programs were executing faster on the Host. For all applications using 64 computing processes and more, the percentage difference (column **(C)**) between Docker and Host for DAC and MasterSlave becomes greater than for a smaller number of processes (except SPMD for 256 computing processes--but this case is already after a significant drop in performance so is not in the area of interest). We put in bold the Docker overhead (in percent) for the number of processes for which the given application obtained the shortest time. For such configurations, we see what we can consider a Docker overhead of between 7.5% and 15.3%. It can be noted that in [28], the authors concluded that for a artery CFD code case in a Lenox cluster (4 nodes with 2\(\times\) Intel Xeon E5-2697v3 and 1 GbE network) and using Docker for a total of 112 threads, the Docker overhead increased with an increasing number of MPI ranks, i.e., it was close to bare metal for 8 \(\times\) 14 (MPI ranks \(\times\) threads per rank) and 16 \(\times\) 7, but approximately 10% for 28 \(\times\) 4 and 56 \(\times\) 2 and even approximately 40% for the 112 \(\times\) 1 case. Due to the possibility of a very easy change of the runtime environment using Docker (as mentioned in Section 4.2), for the sake of performance evaluation of potential progress regarding compilers and software development, a comparison of the execution times using GCC 7.4.0 with OpenMPI 2.1.1 (hereinafter referred to as V7) and GCC 9.3.0 and OpenMPI 3.1.1 (hereinafter referred to as V9) versions was made. In practical terms, though, we would typically use newer stable versions of the compiler and software rather than older ones since such are theoretically improved and maintained better. Table 9 shows for which version of the compiler the compiled program ran faster, using Docker. If the program compiled by the V7 compiler version was faster than using version V9 (for a given configuration), then a respective cell contains V7, otherwise, it contains V9. The value in parentheses denotes in percent how much faster the faster version of program was.