8263018: Improve API for lifecycle of native resources

src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java

@@ -628,7 +628,7 @@ interface VaList extends Addressable {
 
         /**
          * Constructs a new {@code VaList} instance out of a memory address pointing to an existing C {@code va_list},
-         * backed by the global resource scope (see {@link ResourceScope#globalScope()}).
+         * backed by the {@link ResourceScope#globalScope() global} resource scope.
          * <p>
          * This method is <em>restricted</em>. Restricted method are unsafe, and, if used incorrectly, their use might crash
          * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on

src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAddress.java

@@ -92,7 +92,7 @@ default MemoryAddress address() {
      * Returns a shared native memory segment with given size, and whose base address is this address. This method
      * can be useful when interacting with custom native memory sources (e.g. custom allocators), where an address to some
      * underlying memory region is typically obtained from native code (often as a plain {@code long} value).
-     * The returned segment is associated with the global resource scope (see {@link ResourceScope#globalScope()}).
+     * The returned segment is associated with the {@link ResourceScope#globalScope() global} resource scope.
      * <p>
      * Clients should ensure that the address and bounds refers to a valid region of memory that is accessible for reading and,
      * if appropriate, writing; an attempt to access an invalid memory location from Java code will either return an arbitrary value,

src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/ResourceScope.java

@@ -78,9 +78,9 @@
  * associated with this resource scope. Any attempt to perform resource access from a thread other than the
  * owner thread will result in a runtime failure.
  * <p>
- * Shared resource scopes (see {@link #ofShared()}), support strong thread-confinement guarantees. A shared resource scope
- * has no owner thread; as such resources associated with this scope can be accessed by multiple threads. This might be useful
- * when multiple threads need to access the same resource concurrently (e.g. in the case of parallel processing). For instance, a client
+ * Shared resource scopes (see {@link #ofShared()}), on the other hand, have no owner thread; as such resources associated
+ * with this shared resource scopes can be accessed by multiple threads. This might be useful when multiple threads need
+ * to access the same resource concurrently (e.g. in the case of parallel processing). For instance, a client
  * might obtain a {@link Spliterator} from a shared segment, which can then be used to slice the segment and allow multiple
  * threads to work in parallel on disjoint segment slices. The following code can be used to sum all int values in a memory segment in parallel:
  *

src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/SegmentAllocator.java

@@ -461,7 +461,7 @@ static SegmentAllocator arenaUnbounded(ResourceScope scope) {
     }
 
     /**
-     * Returns a native allocator which responds to allocation requests by recycling a single segment; that is,
+     * Returns a segment allocator which responds to allocation requests by recycling a single segment; that is,
      * each new allocation request will return a new slice starting at the segment offset {@code 0} (alignment
      * constraints are ignored by this allocator). This can be useful to limit allocation requests in case a client
      * knows that they have fully processed the contents of the allocated segment before the subsequent allocation request

src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java

@@ -338,11 +338,11 @@ private boolean isSet(int mask) {
 
     private int checkArraySize(String typeName, int elemSize) {
         if (length % elemSize != 0) {
-            throw new UnsupportedOperationException(String.format("Segment size is not a multiple of %d. Size: %d", elemSize, length));
+            throw new IllegalStateException(String.format("Segment size is not a multiple of %d. Size: %d", elemSize, length));
         }
         long arraySize = length / elemSize;
         if (arraySize > (Integer.MAX_VALUE - 8)) { //conservative check
-            throw new UnsupportedOperationException(String.format("Segment is too large to wrap as %s. Size: %d", typeName, length));
+            throw new IllegalStateException(String.format("Segment is too large to wrap as %s. Size: %d", typeName, length));
         }
         return (int)arraySize;
     }

src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/ArenaAllocator.java

@@ -31,6 +31,7 @@ MemorySegment newSegment(long size, long align) {
 
     @Override
     public MemorySegment allocate(long bytesSize, long bytesAlignment) {
+        checkConfinementIfNeeded();
         if (Utils.alignUp(bytesSize, bytesAlignment) > MAX_ALLOC_SIZE) {
             return newSegment(bytesSize, bytesAlignment);
         }
@@ -62,6 +63,13 @@ private MemorySegment trySlice(long bytesSize, long bytesAlignment) {
         }
     }
 
+    private void checkConfinementIfNeeded() {
+        Thread segmentThread = segment.scope().ownerThread();
+        if (segmentThread != null && segmentThread != Thread.currentThread()) {
+            throw new IllegalStateException("Attempt to allocate outside confinement thread");
+        }
+    }
+
     public static class BoundedArenaAllocator extends ArenaAllocator {
 
         public BoundedArenaAllocator(ResourceScope scope, long size) {

test/jdk/java/foreign/TestArrays.java

@@ -108,7 +108,7 @@ public void testArrays(Consumer<MemorySegment> init, Consumer<MemorySegment> che
     }
 
     @Test(dataProvider = "elemLayouts",
-            expectedExceptions = UnsupportedOperationException.class)
+            expectedExceptions = IllegalStateException.class)
     public void testTooBigForArray(MemoryLayout layout, Function<MemorySegment, Object> arrayFactory) {
         MemoryLayout seq = MemoryLayout.ofSequence((Integer.MAX_VALUE * layout.byteSize()) + 1, layout);
         //do not really allocate here, as it's way too much memory
@@ -117,19 +117,19 @@ public void testTooBigForArray(MemoryLayout layout, Function<MemorySegment, Obje
     }
 
     @Test(dataProvider = "elemLayouts",
-            expectedExceptions = UnsupportedOperationException.class)
+            expectedExceptions = IllegalStateException.class)
     public void testBadSize(MemoryLayout layout, Function<MemorySegment, Object> arrayFactory) {
-        if (layout.byteSize() == 1) throw new UnsupportedOperationException(); //make it fail
+        if (layout.byteSize() == 1) throw new IllegalStateException(); //make it fail
         try (ResourceScope scope = ResourceScope.ofConfined()) {
             MemorySegment segment = MemorySegment.allocateNative(layout.byteSize() + 1, layout.byteSize(), scope);
             arrayFactory.apply(segment);
         }
     }
 
     @Test(dataProvider = "elemLayouts",
-            expectedExceptions = UnsupportedOperationException.class)
+            expectedExceptions = IllegalStateException.class)
     public void testArrayFromClosedSegment(MemoryLayout layout, Function<MemorySegment, Object> arrayFactory) {
-        MemorySegment segment = MemorySegment.allocateNative(layout);
+        MemorySegment segment = MemorySegment.allocateNative(layout, ResourceScope.ofConfined());
         segment.scope().close();
         arrayFactory.apply(segment);
     }

test/jdk/java/foreign/TestByteBuffer.java

@@ -454,7 +454,7 @@ public void testBufferOnClosedScope() {
         byteBuffer.get(); // should throw
     }
 
-    @Test(expectedExceptions = UnsupportedOperationException.class)
+    @Test(expectedExceptions = IllegalStateException.class)
     public void testTooBigForByteBuffer() {
         MemorySegment segment = MemoryAddress.NULL.asSegmentRestricted(Integer.MAX_VALUE + 10L);
         segment.asByteBuffer();