/ go Public
runtime: allow no-escape slices of unknown capacity to be allocated to the stack more aggressively #58215
Someone must examine and confirm this is a valid issue and not a duplicate of an existing one.
Whenever a slice is allocated with a variable capacity (e.g. make(int, 0, n)), the compiler concludes it escapes to the heap,
even though the slice does not actually escape.
Notice that this contrasts with escaping conclusions about similar constructs with maps:
I propose to adopt a more aggressive strategy to allocate slices on the stack whenever possible,
whether the capacity is known at build time or not.
Snippet (ii) should be detected as no escape (I believe it is at some point, and we revert to escaping because of the
variable capacity). This would make the escape analysis consistent with maps.
The decision to allocate non-escaping slices to the stack or to the heap should be deferred to runtime,
favoring stack whenever the capacity fits and resorting to heap only for the larger slices.
At the very least, this should favor well-abiding functions that provide a predictable capacity in the call to make (such as snippet (ii)). Growing dynamically the slice is probably a case we could still leave to the heap.
The text was updated successfully, but these errors were encountered: