Home

Cooperative (de)allocation

Summary

Highly controversial, and possibly not much beneficial, attempt to improve (CPU) cache efficiency (and, hopefully, but less likely, decrease CPU usage) for heap (de)allocation/resizing in Rust. Specific/only applicable to Rust (or languages/methodologies with RAII and with support for custom allocators).

Disambiguation

Not related/specific to Rust co-routines (async/await), neither to any cooperative multithreading/multitasking/scheduling.

Goal

Leverage Rust memory & data safety guarantees to streamline de-allocation (and resizing of data on heap).

The problem/waste being solved

When de-allocating, all that Rust passes through the (standard) allocator API is a pointer (to the data being de-allocated). The allocator has to look it up for its housekeeping in its internal data structures (often hash-based).

How (in short)

Rust could keep some extra metadata along every smart pointer. (This metadata would come from the allocator's new functions co_allocate, co_allocate_zeroed, co_grow, co_grow_zeroed, co_shrink.) Then Rust could pass that metadata back (to the allocator) when de-allocating (or resizing). That hopefully saves the allocator (listing the highest benefit first):

• data cache access (looking up auxiliary/hashmap-like record(s) for the given pointer, or its hash, and/or the allocated data length...), and
• code cache access (no need to re-calculate the hash, or its precursor), and
• CPU cycles (calculating the hash, or its precursor, and locating the related entries) - least likely benefit (since this gain is decreased by CPU cycles needed to move the metadata around).

The size of the metadata (per smart pointer) must be known in compile time. Hence, this is supported only for the global allocator, which must define the metadata and make it (somehow) known to the compiler. That may need some new compiler configuration/directives and/or rustc target configuration.

However, this doesn't affect Rust language itself (other than fixing some rustc internal compiler errors). (Would you like this to be clearer? Get in touch & help shape this, or at least shine the light, please.)

Controversy: CPU cycles & Data size

Of course, this increases the size of (affected) smart pointers (wherever used/stored/passed). So, the initial candidates are primarily non-leaf smart pointers (Vec and other containers):

• Passed around (up & down the stack, or stored/moved around on the heap), in total, less than leaf objects. (As data flow accumulated over time. Well designed data structures have more leaves than non-leaves for common input.)
• Small in total size (as per the previous). Then any small metadata (a small multiple of usize, adjacent to those smart pointers) may not increase RAM requirements too much.
• So, (as per the previous two) this metadata may not excessively affect stack depth, neither the data flow & CPU cycles (for many applications).
• Due to the cache waiting times, handling the metadata may increase execution time even less so than it increases the number of CPU cycles (since the CPU waits for the cache anyway). Especially so when these smart pointers are stored on stack (which grows/shrinks sequentially). Therefore the runtime speed cost of handling the metadata may not be as high as it may sound.
• Resizable (which can make use of the metadata): Vec (and hopefully HashMap/HashSet, BTreeMap/BTreeSet).
• (De)allocated or resized frequently. Hence String, or any frequently resized Vec of primitive or static data, too (even though it's a leaf in terms of smart pointer "levels".)
• Of course, leaf smart pointers are more frequently (de)allocated than non-leaf ones (in well designed data structures). But the overall data flow may prohibit them (from using cooperative (de)allocation - unless they are resizable).

Hence, (in general) this would be much less beneficial (or even detrimental) for Box, Rc, Arc. (Or, if anyone implements this for those smart pointers, too, we would see when we are benchmarking this.)

Fringe benefit?

Allocators can store metadata (together with the allocated data) - even without passing it around. How? They can put it "left" of the allocated data: At (consecutive) addresses just below the returned pointer. Then the allocator could read such metadata (and update it, if necessary) on deallocation/resize. This is allocator-agnostic, as the size of metadata can vary from one allocator to another.

However, such allocation, deallocation and resize has to access that metadata from that location (next to the user's allocated data). If the application is not using the allocated data near that moment, this increases the cache reloads.

Also, many resizable data structures (like Vec) are designed to grow in multiples of cache page length. If this (adjacent) metadata size varies between allocators, the data structure size may be more difficult to optimize (to make the total size a multiple of cache page length).

TODO Combine both: Passing metadata around, or storing it left of the allocated data (or neither). Have this configurable: Instead of a bool const generic, pass an enum representing this preference. Then have two where bounds:

• one for usize of metadata passed around, and
• one for the usize of metadata stored left of the allocated data.

Then change the initial size: Subtract the size of metadata left of the allocated data (so that it all fits into a multiple of cache page length).

Controversy & How: Choice, Complexity, Safety, Compatible

Choice

HIGHLY configurable with const generics. To be explained here.

Rust internal complexity

Adding the new functions to the Allocator API (listed above; with defaults/fallbacks) is easy. Implementing them is up to the allocator, and out of scope here. (Do you know of any allocators written primarily in Rust - rather than in C - with developers open to adding new functionality? Please connect us.)

However, most of the work in Rust (alloc/std and core) is about storing and handling the metadata, the developer's choices and defaults.

This affects a lot of Vec, VecDeque (and RawVec) in library/alloc(which is aliased tolibrary/std). Implementing this for String affectsCowandToOwned(inlibrary/core`), too.

Questions

• about names of new methods (Vec::new_co)
• when adding the preference flag to structs/enums/traits that currently only work with the global allocator, should we add the allocator generic parameter (and related methods that accept the allocator instance, similar to the existing Vec::new_in), too?

Application complexity

Types with different COOP_PREFERRED are not compatible.

"Downgrading" from a "cooperative" type to its "non-cooperative" version is zero cost.

However, "upgrading" is not possible. That's unless we make the "cooperative" version always check its metadata to be non-null first. (That would have a fallback to non-cooperative allocator API.)

Safety

HIGHLY safe. To be explained here.

Compatible

Existing crates will stay compatible.

HIGHLY compatible with const generic default values. To be explained here.

Scope & Status

• Primarily, and initially, Vec, VecDeque and RawVec (MVP complete, not tested, not benchmarked).
• Possibly String and related (Cow, ToOwned). (MVP mostly complete, not tested, not benchmarked. Please help.)
• Hopefully HashMap/HashSet, BTreeMap/BTreeSet)
• Unlikely (possible, but with little benefit - as per above), and more involving the compiler & the language internals: Box, Rc, Arc.

Development

See Contributing.