Survey of Memory Management Techniques for HPC and Cloud Computing <s> B. MIGRATION <s> Several studies have shown that Asymmetric Multicore Processors (AMPs) systems, which are composed of processors with different hardware characteristics, present better performance and power when compared to homogeneous systems. With Moore's law behavior still lasting, core-count growth creates typical non-uniform memory accesses (NUMA). Existing schedulers assume that the underlying architecture is homogeneous, and as consequence, they may not be well suited for AMP and NUMA systems, since they, respectively, do not properly explore hardware elements asymmetry, while improving memory utilization by avoid multi-processes data starvation. In this paper we propose a new scheduler, namely NUMA-aware Scheduler, to accommodate the next generation of AMP architectures in terms of architecture asymmetry and processes starvation. Experimental results show that the average speedup is 1.36 times faster than default Linux scheduler through evaluation using PARSEC benchmarks, demonstrating that the proposed technique is promising when compared to other prior studies. <s> BIB001 </s> Survey of Memory Management Techniques for HPC and Cloud Computing <s> B. MIGRATION <s> Upcoming high-performance computing (HPC) platforms will have more complex memory hierarchies with high-bandwidth on-package memory and in the future also non-volatile memory. How to use such deep memory hierarchies effectively remains an open research question. In this paper we evaluate the performance implications of a scheme based on a software-managed scratchpad with coarse-grained memory-copy operations migrating application data structures between memory hierarchy levels. We expect that such a scheme can, under specificcircumstances, outperform a hardware-managed cache while requiring a lot less effort than would a scheme managed entirely by the application programmers. Because suitable hardware is not yet generally available, we propose and benchmark several existing hardware configurations that can be used as approximations, including non-uniform memory access (NUMA) systems and memory on accelerators. We then evaluate data migration mechanisms currently available on Linux systems, such as move_pages and memcpy. We also design a best-case-scenario HPC benchmark to explore how the memory locality and parallelism of applications can be improved by data migration. We find that NUMA systems can be a reasonable approximation platform, especially when auxiliary load mechanisms are employed. Memory migration mechanisms inside the Linux kernel turn out to significantly lag behind a plain user-space memory copy, even after we level the playing field as much as possible. Our dedicated application benchmark demonstrates a significant performance benefit of doing memory migrations—approaching the measured difference in the memory bandwidth—provided that the ratio of worker threads to migration threads is chosen well. <s> BIB002 </s> Survey of Memory Management Techniques for HPC and Cloud Computing <s> B. MIGRATION <s> Nonuniform Memory Access (NUMA) will likely continue to be the chief abstraction used to expose heterogeneous memory. One major problem with using NUMA in this way is, the assignment of memory to devices, mediated by the hardware and Linux OS, is only resolved to page granularity. That is, pages, not allocations, are explicitly assigned to memory devices. This is particularly troublesome if one wants to migrate data between devices: since only pages can be migrated, other data allocated on the same pages will be migrated as well, and it isn't easy to tell what data will be swept along to the target device. We propose a solution to this problem based on repurposing arena-based heap management to keep locality among related data structures that are used together, and discuss our work on such a heap manager. <s> BIB003
The memory pages management approach for various hybrid memories based on page migrations is presented in  . The utility-based hybrid memory management (UH-MEM) systematically estimates both the single application benefits and the overall system benefits of migrating a page between different memory types. Decisions on data placement are based on the estimated benefits. NUMA, that is an abstraction used to expose heterogeneous memory, has one major issue. Data migration between devices is only resolved to page granularity. Other data allocated on the same pages are migrated as well. A solution based on re-purposing arenabased heap management to keep locality among related data structures that are used together is discussed in BIB003 . Two mechanisms available on modern Linux systems for migrating data between physical locations are analysed in BIB002 . Memory migration mechanisms within the Linux kernel are far behind a simple user-space memory copy, and, with additional software degradation, a regular NUMA system can reasonably approach the bandwidth of a deep-memory architecture. Experiments carried out on this approximation platform show that decreasing the number of worker threads and using them for data migration instead allows getting a significant speed-up. Reference BIB001 proposed an operating system to assist the hierarchical memory management system designed for the manycore co-processor based heterogeneous architectures. The co-processor's RAM is controlled entirely by the OS kernel, so the OS is in charge of orchestrating the data movement between the host and the device and of updating the process virtual memory address space. The main motivation for the memory migration is that if a memory page is not migrated along with a task that is migrated to another node, accessing the page on the original node incurs remote memory access. Besides, memory migration is applied between different types of memory, which is especially essential for memory-intensive applications. A general scheme of the memory migration with page granularity is shown in Figure 3 . The migration can be managed both by the OS, as in BIB001 and BIB002 , and by the hardware, as in BIB002 and  . However, page migration is an expensive operation and can lead to additional overhead for memory access due to page granularity. The proposed approaches consider various ways to reduce migration costs.