RFR: 8348668: Prevent first resource cleanup in confined arena from escaping

[Chen Liang]

On Mon, 27 Jan 2025 22:06:58 GMT, Jorn Vernee <jvernee at openjdk.org> wrote:

> Currently, to free the memory allocated in a confined arena, we keep track of a list of 'cleanup actions', stored in linked list format in a so-called `ResourceList`, attached to the scope of the arena. When the scope is closed, we loop over all the entries in this resource list, and run all the cleanup actions one by one.
> 
> However, due to this linked list format, plus the control flow introduced by the cleanup loop, C2's escape analysis can not keep track of the nodes of this linked list (`ResourceList.ResourceCleanup`), and as a result, they can not be scalar replaced.
> 
> We can prevent just the first `ResourceCleanup` instance from escaping, by pulling out the first element of the list into a separate field. I also tried a setup where I had 2 separate fields for the first 2 elements, as well as a setup with an array with a fixed set of elements. While these also worked to prevent the first node from escaping, they were not able to provide the same benefit for multiple resource cleanup instances. Nevertheless, avoiding the allocation of the first element is relatively simple, and seems like a low-hanging fruit.
> 
> I've changed the `AllocTest` benchmark a bit so that we don't return the `MemorySegment` in `alloc_confined`, which would make it always escape. That way, we can use this existing benchmark to test whether there are any allocations when calling `allocate` on a confined arena. This matches what we were doing in the other benchmark methods in the same class.

This somewhat reminds me of #22043, don't know how applicable the block trick is for cleanup, but it doesn't help escape analysis...

src/java.base/share/classes/jdk/internal/foreign/ConfinedSession.java line 112:

> 110:             if (fst != ResourceCleanup.CLOSED_LIST) {
> 111:                 ResourceCleanup prev = fst;
> 112:                 fst = ResourceCleanup.CLOSED_LIST;

Is there a reason why usage of fst here doesn't prevent successful escape analysis?

-------------

PR Review: https://git.openjdk.org/jdk/pull/23321#pullrequestreview-2576802578
PR Review Comment: https://git.openjdk.org/jdk/pull/23321#discussion_r1931348181