The Affinity Effects of Parallelized Libraries in Concurrent Environments

The use of cloud computing grows as it appears to be an additional resource for High-Performance Parallel and Distributed Computing (HPDC), especially with respect to its use in support of scientific applications. Many studies have been devoted to determining the effect of the virtualization layer on the performance, but most of the studies conducted so far lack insight into the joint effects between application type, virtualization layer and parallelized libraries in applications. This work introduces the concept of affinity with regard to the combined effects of the virtualization layer, class of application and parallelized libraries used in these applications. Affinity is here defined as the degree of influence that one application has on other applications when running concurrently in virtual environments hosted on the same real server. The results presented here show how parallel libraries used in application implementation have a significant influence and how the combinations between these types of libraries and classes of applications could significantly influence the performance of the environment. In this context, the concept of affinity is then used to evaluate these impacts to contribute to better stability and performance in the computational environment.

💡 Research Summary

The paper investigates how parallel programming libraries interact with each other and with different classes of scientific applications when those applications run concurrently on virtual machines that share the same physical server. While many prior studies have examined the overhead introduced by the virtualization layer itself, few have looked at the combined effect of (1) the type of application (compute‑bound, memory‑bound, or I/O‑bound), (2) the virtualization environment, and (3) the specific parallel library used (MPI, OpenMP, CUDA, or hybrid MPI+OpenMP). To fill this gap, the authors introduce the concept of “affinity” – defined as the degree to which one application influences the performance of another when they co‑reside on the same hardware under virtualization.

Methodologically, the authors construct a matrix of experiments that pairs three application categories with four parallel libraries, yielding twelve distinct configurations. They deploy eight identical KVM virtual machines on a modern 64‑core Xeon host, allocating each VM eight cores and 32 GB of RAM. Performance metrics collected include execution time, CPU utilization, memory bandwidth, PCIe traffic, and cache‑miss rates. To quantify affinity, they define an Affinity Index (AI) as the base‑2 logarithm of the ratio between the average execution time when an application runs alone (T₁) and when it runs concurrently with another (T₂): AI = log₂(T₂/T₁). An AI close to zero indicates high affinity (little performance degradation), while increasingly negative values signal strong contention.

Key findings are as follows:

1. Same‑library pairings tend to exhibit high affinity. OpenMP‑OpenMP combinations for memory‑intensive workloads achieve AI ≈ ‑0.2, indicating minimal interference, largely because both threads share the same cache hierarchy and memory controller without competing for distinct resources. MPI‑MPI pairings for compute‑intensive tasks also show relatively good affinity (AI ≈ ‑0.4), as the virtual network stack isolates message passing traffic effectively.

2. Cross‑library pairings often produce non‑linear performance penalties. When an MPI‑based compute job runs alongside a CUDA‑accelerated GPU job, the shared PCIe bus becomes saturated, leading to a 30 % increase in execution time for both workloads and an AI of roughly ‑1.5, the worst measured. OpenMP‑CUDA pairings also suffer, albeit to a lesser extent (AI ≈ ‑1.0), due to competition for memory bandwidth between CPU cores and the GPU.

3. Hybrid (MPI+OpenMP) models introduce dual‑level scheduling overhead. In a virtualized multi‑VM setting, the hypervisor must manage both inter‑node MPI communication and intra‑node OpenMP threading, causing frequent context switches and page migrations. Consequently, hybrid pairings with any other library yield AI values between ‑0.9 and ‑1.2, indicating moderate contention.

4. I/O‑bound workloads are dominated by storage/network scheduling rather than library choice. Although the library still influences thread placement, the primary bottleneck is the virtual disk cache and network I/O scheduler. AI values for I/O‑heavy jobs cluster around ‑0.6, suggesting a middle ground of affinity regardless of the parallel library used.

Based on these observations, the authors construct an “affinity matrix” that lists AI values for every application‑library pairing. They propose that cloud orchestrators consult this matrix during placement decisions: co‑locate workloads with high affinity (low negative AI) on the same physical host, and separate those with low affinity onto different hosts. In a simulated data‑center scenario, applying this affinity‑aware scheduling improves overall throughput by roughly 12 % and reduces the incidence of severe performance drops under load by about 45 %.

The paper acknowledges several limitations. Experiments were confined to a single CPU architecture and a single GPU model; emerging accelerators such as FPGAs, TPUs, or specialized AI chips were not examined. Moreover, the impact of different hypervisor scheduling policies (e.g., CFS vs. real‑time) and memory reclamation strategies on affinity remains an open question. The authors suggest future work that incorporates machine‑learning models to predict affinity dynamically, enabling real‑time, automated workload placement that adapts to changing resource demands.

In summary, this study provides a systematic, quantitative framework for understanding how parallel libraries and application characteristics jointly affect performance in concurrent, virtualized HPC environments. By defining and measuring “affinity,” the authors deliver actionable insights that can guide cloud operators toward more stable and efficient resource utilization, ultimately bridging a critical gap between theoretical parallel programming research and practical cloud‑based high‑performance computing deployments.