Mesh

For anyone following the discussion: Mesh (https://github.com/plasma-umass/mesh) is a seriously interesting read.

Worst case, 2× is actually a steal compared to a non-moving allocator such as malloc/free or RC built on top of that, which cannot[1] do better than about 1 + ½log₂(largest allocation / smallest allocation). For example, if you have allocations from 1K to 16K bytes, any malloc/free implementation can require at least 3× the memory you actually use; if from 16 to 16K, 6×; etc. At this point I must mention that paged memory can get you just enough movability that catastrophic fragmentation of this kind is avoided[2] with high probability. Paging tricks can be seriously expensive on a modern multicore processor, though, so I’m not sure this is the way forward. (The paper report only 1% perf overhead for Firefox; I don’t know if that means Firefox is less multithreaded than it could be or what.) [1] https://www.sqlite.org/malloc.html [2] http

Oh, ok. That makes sense. Though I would count the Boehm Garbage Collector as a hack then, too? Apropos hacks, have a look at this memory management 'thing' that doesn't move, but manages to compact: https://github.com/plasma-umass/Mesh

See https://github.com/plasma-umass/Mesh for the code and a link to the paper.

> I've never heard of a reference counting implementation that can handle memory compaction. It's possible to add that in theory. But if you are tracing all your memory anyway so you can compact it, you typically might as well collect the garbage, while you are at it. But: you are in for a treat, someone implemented compaction for malloc/free. See https://github.com/plasma-umass/Mesh They use virtual memory machinery as the necessary indirection to implement compaction, with neither changing any pointers nor reliably distinguishing pointers from integers.

macOS/iOS is a popular platform where the page size is 16KB and RAM is moderately-to-very expensive. It might be interesting to try something like Mesh (https://github.com/plasma-umass/Mesh) to share pages.

You can do interesting things by replacing malloc, like this compacting allocator: https://github.com/plasma-umass/Mesh

This is awesome. Thanks. I found libmesh which looks very interesting: https://github.com/plasma-umass/Mesh

> specifically replying to suggestion that glibc (or any malloc, by which I mean C standard library memory manager) could move memory allocations But I think malloc can move memory allocations - it can move objects out of a page and return it to the kernel by copying objects into an existing page with a gap and then remapping the old addresses onto the copied page. Then the memory has moved but retains the same address and the old page is returned. See for example the Mesh allocator which does this and still manages to expose a conventional malloc interface. https://github.com/plasma-umass/Mesh

Source code is available here in case anyone's interested: https://github.com/plasma-umass/Mesh