On Wed, 15 Jul 2026 19:35:18 GMT, Jorn Vernee <[email protected]> wrote:
> The methods `load()`, `unload()`, `isLoaded()`, and `force()` in > `MemorySegment` currently delegate to `ScopedMemoryAccess` through a set of > `@Scoped` methods, after which the implementation calls into > `java.nio.MappedMemoryUtils`. This means that, when a shared scope is closed > during a call to one of these methods, an exception can be installed at any > point during the execution of the util method. > > The problem is that some parts of these methods are not able to handle such > exceptions being installed. > > We've had some previous discussion about these methods not really needing to > be `@Scoped` in the first place, but instead being able to rely on paired > acquire/release of the session being accessed. This code is not as > performance critical compared to a scoped memory access, since we're doing a > native call any way. > > To avoid issues with exceptions being installed in surprising places, this > patch switches the named methods to use acquire/release instead of being > `@Scoped`. This changes the behavior of these methods slightly: they now keep > the scope alive during the execution of the method. I've updated the doc, > borrowing from existing text in the `Linked::downcallHandle` docs, to explain > that a scope closure may now fail during the execution of one of these > methods. > > Does this seem like the right tradeoff? > > --------- > - [x] I confirm that I make this contribution in accordance with the [OpenJDK > Interim AI Policy](https://openjdk.org/legal/ai). Looks good -- using the handshake mechanism for long-lived and messy operations like load/force has always been a bit of a stretch. This cleans things up. Btw -- one possible way to make this work sort of "for free" would be to turn load/force & co. into downcall handles (which they sort of are, as they are implemented in native anyway). Then, the usual keep-alive mechanism for downcalls would explain why these operations work the way they do. src/java.base/share/classes/java/lang/foreign/Linker.java line 635: > 633: * {@code A.isAccessibleBy(T) == true}. > 634: * Otherwise, the invocation throws {@link > WrongThreadException}; and</li> > 635: * <li>{@code A} is <a > href="MemorySegment.html#segment-alignment">kept alive</a> The link seems wrong src/java.base/share/classes/java/lang/foreign/MemorySegment.java line 509: > 507: * could result in a VM crash when attempting to access the memory > segment. > 508: * > 509: * <h2 id="keep-alive">Keep-alive operations</h2> Good idea! ------------- Marked as reviewed by mcimadamore (Reviewer). PR Review: https://git.openjdk.org/jdk/pull/31918#pullrequestreview-4708237188 PR Comment: https://git.openjdk.org/jdk/pull/31918#issuecomment-4985448048 PR Review Comment: https://git.openjdk.org/jdk/pull/31918#discussion_r3590775037 PR Review Comment: https://git.openjdk.org/jdk/pull/31918#discussion_r3590821219
