Garbage Collection for Multicore Platforms

多核平台的垃圾收集

• 批准号: EP/H026975/1
• 负责人: Richard Jones
• 金额: $ 48.93万
• 依托单位: University of Kent
• 依托单位国家: 英国
• 项目类别: Research Grant
• 财政年份: 2010
• 资助国家: 英国
• 起止时间: 2010 至 无数据
• 项目状态: 已结题
• 来源: https://gtr.ukri.org/projects?ref=EP%2FH026975%2F1
• 关键词: Garbage; Collection; Multicore; Platforms

Developers are increasingly turning to languages like Java and C# for their ease of development, deployment and maintenance. Most applications for the foreseeable future will be written in languages supported by managed runtimes, running on multicore hardware. Particular benefits of managed runtimes include support for automatic dynamic memory management, or 'garbage collection' (GC) and threads. GC allows programs to recycle unused memory automatically, without error-prone programmer intervention. Threading allows a program to run different sequences of instructions in parallel; for instance, a web server might employ a separate thread for each incoming request from internet browsers.One of the most significant recent developments for language implementers is the development of multicore processors, with the number of cores deployed in commodity platforms expected to increase significantly over the next 5 years. The complexity of the processor's access to memory has also increased, in terms of levels of memory hierarchy and in the technology interconnecting processors. However, modern runtime technology has not evolved as fast as hardware technology, and how to fully exploit hardware parallelism remains an open question.This research asks, how can we exploit hardware parallelism, in particular by running multiple user program ('mutator') and GC threads? How can we avoid paying penalties for non-local memory access, but still benefit from multiple paths to memory? How can we take proactive advantage of locality properties? How can we minimise synchronisation between mutator and GC threads?Today's concurrent GC techniques avoid relocating live objects, so as to minimise the need for this synchronisation, but this leads to poor use of memory with many small holes but nowhere to accommodate larger objects ('fragmentation'). The standard fragmentation solution - periodic compaction phases - has high overheads, and often lacks portability or leads to throughput slumps before mutator threads can operate at full speed again. Memory management will be a bottleneck for the next generation of increasingly thread parallel software unless the problem of high performance GC for multicore can be solved. This proposal aims to address this key problem, reconciling compaction with concurrency and performance.We believe that the key to exploiting modern multicore architectures is a judicious division of effort between mutator and GC threads, in order not simply to avoid paying the price of accessing non-local memory, but proactively to process data while it is in the cache. It is almost always worth paying the cost of executing a few more instructions in order to avoid accessing non-local data. Thus, if a mutator thread is about to access data (and hence it is or soon will be in the cache), it should perform some GC work on that data immediately. Other data should be left to be handled by separate GC threads. At no time should all mutator threads be halted waiting for the collector. Our aim is therefore to provide high throughput and very low pauses, by utilising parallel copying collector threads, running concurrently and carefully coupled with mutators in order to leverage locality.This research will benefit GC researchers by broadening the design space and devising and evaluating new concurrent GC techniques, and developers in the broad community through enabling them to tune their applications and GCs to modern architectures. A high-performance GC tuned to modern multicore hardware will also lower the barrier to deployment of future software applications that expect to exploit multicore hardware fully. We will make all code developed freely available under an Open Source license. As well as disseminating our results through journals and conferences, we shall organise two workshops in order to build UK research strength in this field.

开发人员越来越多地转向像Java和c#这样的语言，因为它们易于开发、部署和维护。在可预见的未来，大多数应用程序将使用托管运行时支持的语言编写，运行在多核硬件上。托管运行时的特殊好处包括支持自动动态内存管理，或“垃圾收集”（GC）和线程。GC允许程序自动回收未使用的内存，而不需要程序员的干预。线程允许程序并行运行不同的指令序列；例如，web服务器可以为来自Internet浏览器的每个传入请求使用单独的线程。对于语言实现者来说，最近最重要的发展之一是多核处理器的发展，预计在未来5年内，商用平台上部署的核心数量将显著增加。处理器访问内存的复杂性也增加了，就内存层次和处理器互连技术而言。然而，现代运行时技术的发展速度不如硬件技术，如何充分利用硬件并行性仍然是一个悬而未决的问题。这项研究提出，我们如何利用硬件并行性，特别是通过运行多用户程序（“mutator”）和GC线程？我们如何避免为非本地内存访问付出代价，同时又能从多路径访问内存中获益？我们如何积极利用局部性？我们如何最小化mutator和GC线程之间的同步？今天的并发GC技术避免重新定位活动对象，以尽量减少对这种同步的需求，但这导致内存使用不良，有许多小孔，但没有地方容纳更大的对象（“碎片”）。标准的碎片解决方案——周期性压缩阶段——开销很高，而且通常缺乏可移植性，或者在mutator线程再次全速运行之前导致吞吐量下降。内存管理将成为下一代线程并行软件的瓶颈，除非多核高性能GC问题能够得到解决。这个建议旨在解决这个关键问题，调和压缩与并发性和性能。我们认为，利用现代多核架构的关键是在mutator线程和GC线程之间明智地划分工作量，这不仅是为了避免访问非本地内存的代价，而且是为了主动处理缓存中的数据。为了避免访问非本地数据，多执行一些指令几乎总是值得的。因此，如果一个mutator线程即将访问数据（因此它现在或即将在缓存中），它应该立即对该数据执行一些GC工作。其他数据应该留给单独的GC线程处理。任何时候都不应该停止所有的mutator线程，等待收集器。因此，我们的目标是提供高吞吐量和非常低的暂停，通过利用并行复制收集器线程，并发运行并小心地与mutator耦合，以利用局域性。这项研究将扩大GC研究人员的设计空间，设计和评估新的并发GC技术，并使广大社区的开发人员能够将他们的应用程序和GC调整到现代体系结构，从而使他们受益。针对现代多核硬件进行了调优的高性能GC还将降低期望充分利用多核硬件的未来软件应用程序的部署障碍。我们将在开源许可下免费提供所有开发的代码。除了通过期刊和会议传播我们的研究成果外，我们还将组织两次研讨会，以建立英国在该领域的研究实力。

项目成果

Exploring garbage collection with haswell hardware transactional memory

使用 Haswell 硬件事务内存探索垃圾回收

• DOI: 10.1145/2602988.2602992
• 发表时间: 2014
• 作者: Ritson C

A black-box approach to understanding concurrency in DaCapo

理解 DaCapo 并发性的黑盒方法

• DOI: 10.1145/2398857.2384641
• 发表时间: 2012
• 期刊: ACM SIGPLAN Notices
• 作者: Kalibera T

Quantifying Performance Changes with Effect Size Confidence Intervals

用效应大小置信区间量化性能变化

• 发表时间: 2012
• 作者: Kalibera, T

The locality of concurrent write barriers

• DOI: 10.1145/1806651.1806666
• 发表时间: 2010-06
• 作者: L. Hellyer;Richard E. Jones;Antony Hosking

The Garbage Collection Handbook: The art of automatic memory management

• 发表时间: 2011-08
• 作者: Richard E. Jones;Antony Hosking;J. Moss