Two major trends in high-performance computing, namely, larger numbers of cores and the growing size of on-chip cache memory, are creating significant challenges for evaluating the design space of future processor architectures. Fast and scalable simulations are therefore needed to allow for sufficient exploration of large multi-core systems within a limited simulation time budget. By bringing together accurate high-abstraction analytical models with fast parallel simulation, architects can trade off accuracy with simulation speed to allow for longer application runs, covering a larger portion of the hardware design space. Interval simulation provides this balance between detailed cycle-accurate simulation and one-IPC simulation, allowing long-running simulations to be modeled much faster than with detailed cycle-accurate simulation, while still providing the detail necessary to observe core-uncore interactions across the entire system. Validations against real hardware show average absolute errors within 25% for a variety of multi-threaded workloads; more than twice as accurate on average as one-IPC simulation. Further, we demonstrate scalable simulation speed of up to 2.0 MIPS when simulating a 16-core system on an 8-core SMP machine.

https://users.elis.ugent.be/~leeckhou/papers/sc11.pdf

Sniper: exploring the level of abstraction for scalable and accurate parallel multi-core simulation

This paper analyzes the scalability of seven system applications (Exim, memcached, Apache, PostgreSQL, gmake, Psearchy, and MapReduce) running on Linux on a 48- core computer. Except for gmake, all applications trigger scalability bottlenecks inside a recent Linux kernel. Using mostly standard parallel programming techniques-- this paper introduces one new technique, sloppy counters-- these bottlenecks can be removed from the kernel or avoided by changing the applications slightly. Modifying the kernel required in total 3002 lines of code changes. A speculative conclusion from this analysis is that there is no scalability reason to give up on traditional operating system organizations just yet.

/pdf/an-analysis-of-linux-scalability-to-many-cores-22vvkn5kqo.pdf

An analysis of Linux scalability to many cores

Symmetric multiprocessing (SMP) virtual machines (VMs) allow users to take advantage of a multiprocessor infrastructure. Despite the advantage, SMP VMs can cause synchronization latency to increase significantly, depending on task scheduling. In this paper, we show that even if a SMP VM runs non-concurrent applications, the synchronization latency problem can still occur due to synchronization in the VM kernel.Our experiments show that both of the widely used open source hypervisors, Xen and KVM, with the default schedulers are susceptible to the synchronization latency problem. To remediate this problem, previous works propose a co-scheduling solution where virtual CPUs (vCPUs) of a SMP VM are scheduled simultaneously. However, the co-scheduling approach can cause CPU fragmentation that reduces CPU utilization, priority inversion that degrades I/O performance, and execution delay, leading to deployment impediment. We propose a balance scheduling algorithm which simply balances vCPU siblings on different physical CPUs without forcing the vCPUs to be scheduled simultaneously. Balance scheduling can achieve similar or (up to 8%) better application performance than co-scheduling without the co-scheduling drawbacks, thereby benefiting various SMP VMs. The evaluation is thoroughly conducted against both concurrent and non-concurrent applications with CPU-bound, I/O-bound, and network-bound workloads in KVM. For empirical comparison, we also implement the co-scheduling algorithm on top of KVM's Completely Fair Scheduler (CFS). Compared to the synchronization-unaware CFS, balance scheduling can significantly improve application performance in a SMP VM (e.g. reduce the average TPC-W response time by up to 85%).

/pdf/is-co-scheduling-too-expensive-for-smp-vms-5kypzixx8l.pdf

Is co-scheduling too expensive for SMP VMs?

With a growing concern on the considerable energy consumed by data centers, research efforts are targeting toward green data centers with higher energy efficiency. In particular, server virtualization is emerging as the prominent approach to consolidate applications from multiple applications to one server, with an objective to save energy usage. However, little understanding has been obtained about the potential overhead in energy consumption and the throughput reduction for virtualized servers in data centers. In this research, we take the initiative to characterize the energy usage on virtualized servers. An empirical approach is adopted to investigate how server virtualization affects the energy usage in physical servers. Through intensive data collection and analysis, we identify a fundamental trade-off between the energy saving from server consolidation and the detrimental effects (e.g., energy overhead and throughput reduction) from server virtualization. This characterization lays a mathematical foundation for server consolidation in green data center architecture.

Energy efficiency and server virtualization in data centers: An empirical investigation

Virtualization has gained great acceptance in the server and cloud computing arena. In recent years, it has also been widely applied to real-time embedded systems with stringent timing constraints. We present a comprehensive survey on real-time issues in virtualization for embedded systems, covering popular virtualization systems including KVM, Xen, L4 and others.

/pdf/a-state-of-the-art-survey-on-real-time-issues-in-embedded-2dhj1dzwbx.pdf

A State-of-the-Art Survey on Real-Time Issues in Embedded Systems Virtualization

CPU scheduler is a very important subsystem which affects system throughput, interactivity and fairness. The development of Linux kernel is relatively fast-paced. By now, many CPU schedulers have been designed by researchers, hobbyists and kernel hackers. It is necessary to accurately compare and analyze different characteristics among these schedulers, so as to understand and design better CPU schedulers for various applications. However, researchers lack a straight-forward method to compare and analyze these CPU schedulers precisely. In this paper, we systematically analyze and measure fairness, interactivity and multi-processors performance of three schedulers: O(1), RSDL and CFS, by using micro, synthesis and real application benchmarks. They have been ported into one scheduler framework in Linux kernel-2.6.29. Experimental results show that there are notable differences in fairness and interactivity under micro benchmarks, while minor differences in synthesis and real applications. We also analyze the impact of implementations of schedulers on fairness and interactivity of applications, discuss challenges in estimating application resource requirements in different environments, and present some ideas for developing future CPU schedulers.

Fairness and Interactivity of Three CPU Schedulers in Linux

Multi-core architecture provides more on-chip parallelism and powerful computational capability. It helps virtualization achieve scalable performance. KVM (kernel based virtual machine) is different from other virtualization solutions which can make use of the Linux kernel components such as Completely Fair Scheduler (CFS). However, CFS treats the KVM threads as normal tasks without considering about their unique features such as thread allocation mechanism and lock inside guest virtual machine, which may harm the KVM virtualization performance. In this paper, we analyze a phenomenon that some guest multi-threaded applications have very low performance when scheduled by CFS. As a solution to this problem, we introduce two kinds of optimizations in CFS: (1) Configuration Optimizations (2) Lock Optimizations. Our contributions are: (1) implement 5 original and 2 newest proposed optimizations in the newest Linux kernel. (2) Classify and compare them, a brief analysis is also given. They are all very simple and general to other virtual machine monitors such as Xen and schedulers as O(1). The performance of our CFS optimizations to KVM threads is measured by running some well-known benchmarks in two guest virtual machines on an 8-core server which models the real world applications. The results indicate our scheduling optimizations can improve the overall system performance. This paper can provide useful advices to KVM developers and virtualization data center administrators.

CFS Optimizations to KVM Threads on Multi-Core Environment

In response to the increasing ubiquity of multicore processors, there has been widespread development of multithreaded applications that strive to realize their full potential. Unfortunately, lock contention within operating systems can limit the scalability of multicore systems so severely that an increase in the number of cores can actually lead to reduced performance (i.e., scalability collapse).Existing efforts of solving scalability collapse mainly focus on making critical sections of kernel code fine-grained or designing new synchronization primitives. However, these methods have disadvantages in scalability or energy efficiency. In this article, we observe that the percentage of lock-waiting time over the total execution time for a lock intensive task has a significant correlation with the occurrence of scalability collapse. Based on this observation, a lock-contention-aware scheduler is proposed. Specifically, each task in the scheduler monitors its percentage of lock waiting time continuously. If the percentage exceeds a predefined threshold, this task is considered as lock intensive and migrated to a Special Set of Cores (i.e., SSC). In this way, the number of concurrently running lock-intensive tasks is limited to the number of cores in the SSC, and therefore, the degree of lock contention is controlled. A central challenge of using this scheme is how many cores should be allocated in the SSC to handle lock-intensive tasks. In our scheduler, the optimal number of cores is determined online by the model-driven search.The proposed scheduler is implemented in the recent Linux kernel and evaluated using micro- and macrobenchmarks on AMD and Intel 32-core systems. Experimental results suggest that our proposal is able to remove scalability collapse completely and sustains the maximal throughput of the spin-lock-based system for most applications. Furthermore, the percentage of lock-waiting time can be reduced by up to 84p. When compared with scalability collapse reduction methods such as requester-based locking scheme and sleeping-based synchronization primitives, our scheme exhibits significant advantages in scalability, power consumption, and energy efficiency.

https://dl.acm.org/doi/pdf/10.1145/2400682.2400703

Lock-contention-aware scheduler: A scalable and energy-efficient method for addressing scalability collapse on multicore systems

With the development of transistor technology, multi-core has become mainstream. Predictions based on Moore's Law state that a processor chip can accommodate thousands of cores in 5–10 years. As the system software between applications and hardware, can operating systems scale with the number of cores and achieve the performance potential? In order to answer this question, a micro-benchmark suite OSMark is designed to understand the parallel scalability of operating systems on large scale multi-cores. Different from application-oriented benchmark, OSMark works by stressing separate parts of an operating system including process management, memory management, network, file descriptor operation and System V IPC. Evaluations on AMD 32-core machine with Linux as its OS indicate that most of benchmarks in OSMark scale bad. Linux kernel source code analysis and performance data reveal that kernel synchronization primitives protecting the shared data are the main bottlenecks limiting parallel scalability.

OSMark: A benchmark suite for understanding parallel scalability of operating systems on large scale multi-cores

In this paper, we evaluate and compare the parallel scalability of three commodity operating systems (Linux, Solaris and FreeBSD) on an AMD 32-core platform. Measurements of microbenchmarks and a real-life application reveal that no operating system scales totally better than another for microbenchmarks; for the real-life application, Linux and Solaris are competitive in scalability and perform better than FreeBSD. Related kernel source analysis and performance data suggest that synchronization primitives protecting the shared data structure in kernels are the root cause of the poor scalability on multi-cores.

Yan Cui

Papers

Fairness and Interactivity of Three CPU Schedulers in Linux

CFS Optimizations to KVM Threads on Multi-Core Environment

Lock-contention-aware scheduler: A scalable and energy-efficient method for addressing scalability collapse on multicore systems

OSMark: A benchmark suite for understanding parallel scalability of operating systems on large scale multi-cores

Scalability comparison of commodity operating systems on multi-cores