Conversation

Long thread about allocator design choices: twitter.com/DanielMicay/st. It's entirely possible to provide a hardened allocator with decent performance, low memory use and great scalability without giving up core security properties like fully out-of-line and authoritative metadata.
Quote Tweet
Replying to @ebeip90 and @crypt0ad
Scudo is entirely based on inline metadata and free lists. It relies on CRC32 to detect metadata corruption and can't reliably detect invalid free in the same way. Having fully out-of-line metadata is extremely important for providing many other security properties too.
1
10
I've worked a lot on performance-oriented allocators too and most of those projects are focused on the wrong things. For example, using thread caches as anything more than a way to amortize locking costs is missing the point and hurting real world performance by wasting memory.
1
2
One of the highest priorities for a perf-oriented allocator should be keeping the working set of memory small by minimizing internal / external fragmentation and reducing memory held in caches. Understanding real world performance well is why jemalloc is being adopted everywhere.
1
2
The jemalloc design choices are bad for security, but it's an incredibly good allocator for long-term performance in everything but small programs. It has a strong focus on having minimal fragmentation and keeping other waste (metadata) at a tiny percentage of allocated memory.
1
Google's TCMalloc was too concerned with performance of the allocator rather than applications and systems as a whole. Android chose jemalloc as the dlmalloc replacement despite jemalloc being maintained by Facebook and being somewhat more oriented towards server workloads.
Replying to
I do think thread caches make sense most allocators, but they can accomplish nearly their entire purpose without being larger than arrays of about 16 pointers per size class, to reducing locking overhead to 1/8 (a simple approach is fill half when empty, flush half when full).
2
It doesn't fit into a hardened allocator design since it screws up having proper authoritative metadata and adds a lot of determinism even if it's randomized. However, it's not a huge loss unless you miss the real core purpose: amortizing locking costs, not so much scalability.
1