To this day, efficient timer management is a major challenge in virtualized environments. Contemporary timekeeping techniques in guest kernels frequently interact with timer hardware, which requires continual and costly hypervisor interference.

Despite great advancements in hardware-assisted virtualization of the x86 architecture, certain workloads still suffer significant overhead. This article dissects said overhead in the context of multi-threading. We describe the state-of-the-art, pinpoint challenges, and suggest improvements, aiming to provide a valuable reference to developers and users of virtualization systems alike. We study the virtualization overhead of the PARSEC and SPLASH2X multithreaded benchmarks in a variety of scenarios using a state-of-the-art system. Through controlled experiments, source code analysis and literature review, we quantify the virtualization overhead multithreading still induces and link it to its root causes, after which we suggest possible mitigation strategies. Multithreading still induces high virtualization overhead, mainly caused by synchronization, spinning at user level and NUMA management. The overhead is diverse in nature and embodiment as it is a function of many system and workload properties. System-level solutions are feasible, but often imply difficult trade-offs. Systematic workload optimization is a promising alternative.

Due to its numerous advantages, the IT industry is moving more and more towards the cloud for hosting applications. Reducing the virtualization overhead inherent to cloud computing has therefore been a topic of much research and innovation, resulting in a drastic reduction of this overhead for most workloads. For specific tasks however, challenges remain. One example is parallel, CPU-intensive workloads. Studies concerning this specific workload exist, but focus on low-level properties of the virtualization process, which are often out of reach of the application programmer in commercial cloud environments. Therefore, we aim to approach virtualization overhead from an application architecture and implementation perspective, and provide guidelines for application programmers to develop their software in such a way that they avoid virtualization overhead without the need for access to the hypervisor or specific hardware. As a first step towards this goal, this paper offers a proof of concept applied to the dedup benchmark from the PARSEC benchmark suite, which is notorious for its high virtualization overhead. We provide an alternative implementation of this benchmark, which suffers negligible virtualization overhead compared to the original, thus increasing performance by up to 45%.