Survey of Memory Management Techniques for HPC and Cloud Computing <s> F. SHARED MEMORY <s> Virtual machine environments are becoming more common due to the increased performance of commodity hardware and the emergence of cloud computing for large scale applications. As the use of virtual machines continues to grow, performance critical applications will require efficient mechanisms to achieve their tasks. ::: We introduce Nahanni as a mechanism for shared memory communication in virtual machine environments. Nahanni allows virtualized applications, those running inside virtual machines, to communicate through shared memory for both data movement and synchronization when VMs are co-located on the same host machine. We describe the design, implementation, and evaluation of Nahanni as part of the QEMU/KVM virtualization platform. ::: We have modified existing communication layers to measure the performance benefit of Nahanni. Through microbenchmarks and applications, we demonstrate that shared memory is a useful and efficient communication mechanism in virtualized environments. Further, we discuss how the design and implementation of Nahanni enables a new class of applications, ones that use structured data, to benefit from the use of shared memory. <s> BIB001 </s> Survey of Memory Management Techniques for HPC and Cloud Computing <s> F. SHARED MEMORY <s> Shared memory management is widely recognized as an optimization technique in the virtualized cloud. Most current shared memory techniques allocate shared memory resources from guest VMs based on pre-defined system configurations. Such static management of shared memory not only increases the VM memory pressure, but also limits the flexibility to balance shared memory resources across multiple VMs running on a single host. In this paper, we present a dynamic shared memory management framework that enables multiple VMs to dynamically access shared memory resources according to their demands. We illustrate our system design through two case studies: One aims to improve the performance of interdo main communication while the other aims to improve VM memory swapping efficiency. We demonstrate that the dynamic shared memory mechanism not only improves the utilization of shared memory resources but also significantly enhances the performance of VM applications. Our experimental results show that by using dynamic shared memory management, we can improve the performance of inter-VM communication by up to 45 times, while mitigating the VM memory swapping overhead by up to 58%. <s> BIB002 </s> Survey of Memory Management Techniques for HPC and Cloud Computing <s> F. SHARED MEMORY <s> Virtual machines (VMs) and virtualization are one of the core computing technologies today. Inter-VM communication is not only prevalent but also one of the leading costs for data-intensive systems and applications in most data centers and cloud computing environments. One way to improve inter-VM communication efficiency is to support coresident VM communication using shared-memory-based methods and resort to the traditional TCP/IP for communications between VMs that are located on different physical machines. In recent years, several independent kernel development efforts have been dedicated to improving communication efficiency between coresident VMs using shared-memory channels, and the development efforts differ from one another in terms of where and how the shared-memory channel is established. In this article, we provide a comprehensive overview of the design choices and techniques for performance optimization of coresident inter-VM communication. We examine the key issues for improving inter-VM communication using shared-memory-based mechanisms, such as implementation choices in the software stack, seamless agility for dynamic addition or removal of coresident VMs, and multilevel transparency, as well as advanced requirements in reliability, security, and stability. An in-depth comparison of state-of-the-art research efforts, implementation techniques, evaluation methods, and performance is conducted. We conjecture that this comprehensive survey will not only provide the foundation for developing the next generation of inter-VM communication optimization mechanisms but also offers opportunities to both cloud infrastructure providers and cloud service providers and consumers for improving communication efficiency between coresident VMs in virtualized computing platforms. <s> BIB003 </s> Survey of Memory Management Techniques for HPC and Cloud Computing <s> F. SHARED MEMORY <s> Summary ::: Virtual clusters (VCs) have exhibited various advantages over traditional cluster computing platforms by virtue of their extensibility, reconfigurability, and maintainability. As such, they have become a major execution environment for cloud-based cluster applications. However, compared with traditional clusters, their distributed-memory programming paradigm still remains largely unchanged, which implies that cluster applications cannot be efficiently deployed in VCs, especially when virtual machines (VMs) are running in different physical hosts. Recently, some efforts have been made to improve inter-VM communication, resulting in many studies on how cluster applications could take advantages of VCs. However, most of them mainly focus on the situation that the VMs are all coresident on the same physical machine where the message passing mechanism is usually optimized away by exploiting the host's shared memory. In this paper, we present a design and implementation of Naplus, a kernel-based virtual machine approach to the inter-VM communications that are across different physical hosts. Naplus is based on Nahanni, a mechanism for shared-memory communication in virtual environments. As such, it not only inherits the major merits of Nahanni with respect to flexible data structures and efficient synchronization but also achieves a shared-memory paradigm among VMs. With Naplus, we enable the size of shared space to be maximized as large as the sum of each machine's local memory to accommodate cluster applications with large memory footprints. We prototype Naplus in a dual-host system where an empirical study is conducted to show the effectiveness of the Naplus approach in achieving distributed shared memory for VCs in data centers. Copyright © 2017 John Wiley & Sons, Ltd. <s> BIB004
Recent development has been dedicated to improving communication efficiency between VMs using shared-memory channels. Shared memory is used in cloud solutions to reduce the overhead of data access and to increase resource sharing between different VMs or between VMs and a host. Several techniques have been proposed that differ in terms of where and how the shared-memory channel is established. Host allocated dynamic shared memory is presented in Figure 21(a) . The dynamically managed shared memory regions allow each VM to access the shared memory based on its workload requirements. In BIB002 , a dynamic shared memory management framework was presented. The proposed approach allows multiple VMs to access shared memory resources in accordance with their demands dynamically, thereby improving VM communication efficiency and VM memory swapping efficiency. A general scheme of the VM communication via shared memory swapping is shown in Figure 21(b) . A mechanism that allows VMs distributed on different physical hosts to share their local memory was presented in BIB004 . Naplus was implemented in a dual-host system as a software DSM between VMs by multiplexing the Nahanni BIB001 device in each host. A general scheme of the inter-domain communication via shared memory is shown in Figure 21(c) . It manages the local and remote memory accesses via a simplified lazy consistency memory model. The performance of the shared-memory mechanism for the VM communication depends on a number of factors, such as an implementation layer in the software stack. The implementation layer impacts on the programming transparency, hypervisor transparency and performance BIB003 . Implementing shared-memory for VM communication at the libraries and system calls layer leads to the need for application modifications. The shared-memory implementation above transport layer will result in missing some critical TCP/IP features, such as reliability. Finally, the shared-memory implementation below the IP layer provides high transparency and reliability but may incur high overhead.