papers-we-love_papers-we-love/memory_management/README.md

## Memory Management

* [A Unified Theory of Garbage Collection](https://web.eecs.umich.edu/~weimerw/2012-4610/reading/bacon-garbage.pdf)

* [Teaching Garbage Collection without Implementing Compilers or Interpreters](https://cs.brown.edu/~sk/Publications/Papers/Published/cgkmf-teach-gc/paper.pdf)

* [Message Analysis Guided Allocation and Low Pause Incremental GC in a Concurrent Language](http://user.it.uu.se/~kostis/Papers/ismm04.pdf)

* [And Then There Were None: A Stall-Free Real-Time Garbage Collector for Reconfigurable Hardware](https://cacm.acm.org/magazines/2013/12/169948-and-then-there-were-none/fulltext)

* [The Slab Allocator: An Object-Caching Kernel Memory Allocator](https://www.usenix.org/legacy/publications/library/proceedings/bos94/bonwick.html)
  - [ASCII version](https://www.usenix.org/legacy/publications/library/proceedings/bos94/full_papers/bonwick.a)
  - [POSTSCRIPT version](https://www.usenix.org/legacy/publications/library/proceedings/bos94/full_papers/bonwick.ps)

* :scroll: [ScatterAlloc: Massively Parallel Dynamic Memory Allocation for the GPU](https://markussteinberger.net/papers/ScatterAlloc.pdf)

  Presents a useful algorithm as well as considerations relevant to designing algorithms for GPUs.


* [:scroll:](making-lockless-synchronization-fast.pdf) [Making Lockless Synchronization Fast: Performance Implications of Memory Reclamation](http://www.rdrop.com/users/paulmck/RCU/hart_ipdps06.pdf)
 
    Multicore systems are ubiquitous but modern concurrent programming
techniques still do not see wide-spread adoption. Most concurrent software
(developed in low-level languages) still relies on error-prone and unscalable
memory management techniques for correctness despite the introduction of
superior methods over 30 years ago. Safe memory reclamation allows for
performant and robust memory management that is also suitable for advanced
concurrent programming techniques such as non-blocking synchronization. If
properly used, safe memory reclamation techniques allow improved performance and
simplicity without the complexity of full-blown garbage collection. This paper
provides a terrific overview of common safe memory reclamation mechanisms and
then explores their performance implications.
Update to all READMEs for hosted content reorganization of so-called historical papers 2015-10-07 19:11:04 +00:00			`## Memory Management`

Fixes some broken links and increases max retries for lychee (#659) This will hopefully reduce the false reports due to some unreliable hosters. * Fixes broken links in memory_management/README.md * Fixes broken link in audio_comp_sci/README.md * Fixes broken link in security/README.md * Fixes broken links in garbage_collection/README.md * Increase max retries for lychee 2022-04-09 16:05:02 +00:00			`* [A Unified Theory of Garbage Collection](https://web.eecs.umich.edu/~weimerw/2012-4610/reading/bacon-garbage.pdf)`
first run-through on audit before distro systems 2014-03-08 08:04:09 +00:00
Fixing readme entry in memory management (#416) Teaching Garbage Collection without Implementing Compilers or Interpreters was pointing to a broken link. I am making a change to put to a link still active with the same paper. 2016-09-18 03:23:02 +00:00			`* [Teaching Garbage Collection without Implementing Compilers or Interpreters](https://cs.brown.edu/~sk/Publications/Papers/Published/cgkmf-teach-gc/paper.pdf)`
papers: add added 3 papers from the thesis: Efficient Memory Management for Message Passing Concurrency 2014-03-28 21:45:53 +00:00
			`* [Message Analysis Guided Allocation and Low Pause Incremental GC in a Concurrent Language](http://user.it.uu.se/~kostis/Papers/ismm04.pdf)`
add papers from peter burka, including the one he'll present in nyc, crossing-the-gap 2014-09-08 17:21:56 +00:00
Fixes some broken links and increases max retries for lychee (#659) This will hopefully reduce the false reports due to some unreliable hosters. * Fixes broken links in memory_management/README.md * Fixes broken link in audio_comp_sci/README.md * Fixes broken link in security/README.md * Fixes broken links in garbage_collection/README.md * Increase max retries for lychee 2022-04-09 16:05:02 +00:00			`* [And Then There Were None: A Stall-Free Real-Time Garbage Collector for Reconfigurable Hardware](https://cacm.acm.org/magazines/2013/12/169948-and-then-there-were-none/fulltext)`
Add ScatterAlloc paper This paper was celebrated at PWLMTL#2 by Peter Zion, who also used it as a springboard to discuss GPU architecture in general, as well as his implementation based on the paper in the Fabric Engine framework (fabricengine.com). 2014-11-05 23:06:48 +00:00
Update README w/ bonwick slab allocator paper 2015-08-14 18:41:29 +00:00			`* [The Slab Allocator: An Object-Caching Kernel Memory Allocator](https://www.usenix.org/legacy/publications/library/proceedings/bos94/bonwick.html)`
			`- [ASCII version](https://www.usenix.org/legacy/publications/library/proceedings/bos94/full_papers/bonwick.a)`
			`- [POSTSCRIPT version](https://www.usenix.org/legacy/publications/library/proceedings/bos94/full_papers/bonwick.ps)`

Fixes some broken links and increases max retries for lychee (#659) This will hopefully reduce the false reports due to some unreliable hosters. * Fixes broken links in memory_management/README.md * Fixes broken link in audio_comp_sci/README.md * Fixes broken link in security/README.md * Fixes broken links in garbage_collection/README.md * Increase max retries for lychee 2022-04-09 16:05:02 +00:00			`* :scroll: [ScatterAlloc: Massively Parallel Dynamic Memory Allocation for the GPU](https://markussteinberger.net/papers/ScatterAlloc.pdf)`
Update to all READMEs for hosted content reorganization of so-called historical papers 2015-10-07 19:11:04 +00:00
			`Presents a useful algorithm as well as considerations relevant to designing algorithms for GPUs.`


			`* [:scroll:](making-lockless-synchronization-fast.pdf) [Making Lockless Synchronization Fast: Performance Implications of Memory Reclamation](http://www.rdrop.com/users/paulmck/RCU/hart_ipdps06.pdf)`

			`Multicore systems are ubiquitous but modern concurrent programming`
			`techniques still do not see wide-spread adoption. Most concurrent software`
			`(developed in low-level languages) still relies on error-prone and unscalable`
			`memory management techniques for correctness despite the introduction of`
			`superior methods over 30 years ago. Safe memory reclamation allows for`
			`performant and robust memory management that is also suitable for advanced`
			`concurrent programming techniques such as non-blocking synchronization. If`
			`properly used, safe memory reclamation techniques allow improved performance and`
			`simplicity without the complexity of full-blown garbage collection. This paper`
			`provides a terrific overview of common safe memory reclamation mechanisms and`
			`then explores their performance implications.`