Rename isOwnedBy -> isCloseableBy

Fix minor typos
Fix StrLenTest/RingAllocator

Author: mcimadamore

src/java.base/share/classes/java/lang/foreign/Arena.java

@@ -65,15 +65,15 @@
  * and <em>shared</em> arenas.
  * <p>
  * Confined arenas, support strong thread-confinement guarantees. Upon creation, they are assigned an
- * {@linkplain #isOwnedBy(Thread) owner thread}, typically the thread which initiated the creation operation.
+ * {@linkplain #isCloseableBy(Thread) owner thread}, typically the thread which initiated the creation operation.
  * The segments created by a confined arena can only be {@linkplain MemorySession#isAccessibleBy(Thread) accessed}
  * by the thread that created the arena. Moreover, any attempt to close the confined arena from a thread other than the owner thread will
  * fail with {@link WrongThreadException}.
  * <p>
  * Shared memory sessions, on the other hand, have no owner thread. The segments created by a shared arena
  * can be {@linkplain MemorySession#isAccessibleBy(Thread) accessed} by multiple threads. This might be useful when
  * multiple threads need to access the same memory segment concurrently (e.g. in the case of parallel processing).
- * Moreover, a shared arena can be closed by any thread.
+ * Moreover, a shared arena {@linkplain #isCloseableBy(Thread) can be closed} by any thread.
  *
  * @since 20
  */
@@ -128,7 +128,7 @@ default MemorySegment allocate(long byteSize, long byteAlignment) {
      * {@return {@code true} if the provided thread can close this arena}
      * @param thread the thread to be tested.
      */
-    boolean isOwnedBy(Thread thread);
+    boolean isCloseableBy(Thread thread);
 
     /**
      * Creates a new confined arena.
@@ -159,9 +159,10 @@ public void close() {
             }
 
             @Override
-            public boolean isOwnedBy(Thread thread) {
+            public boolean isCloseableBy(Thread thread) {
                 Objects.requireNonNull(thread);
-                return sessionImpl.ownerThread() == thread;
+                return sessionImpl.ownerThread() == null || // shared
+                        sessionImpl.ownerThread() == thread;
             }
         };
     }

src/java.base/share/classes/java/lang/foreign/MemorySession.java

@@ -43,14 +43,14 @@
  * explicitly, (i.e. using an {@linkplain Arena arena}) or implicitly, by the garbage collector. When a bounded memory
  * session ends, it is no longer {@linkplain #isAlive() alive}, and subsequent operations
  * on the segments associated with that bounded session (e.g. {@link MemorySegment#get(ValueLayout.OfInt, long)})
- * will fail with {@link IllegalStateException}. Moreover, to prevent temporal safety, access to memory segments associated with
+ * will fail with {@link IllegalStateException}. Moreover, to guarantee temporal safety, access to memory segments associated with
  * bounded sessions might be <a href="Arena.html#thread-confinement">restricted to specific threads</a>.
  *
  * <h2 id="implicit">Implicitly-managed bounded memory sessions</h2>
  *
  * Managing bounded memory session explicitly, using arenas, while powerful, must be used with caution. An arena must always
  * be closed when no longer in use (this is done using {@link Arena#close()}). A failure to do so
- * might result in memory leaks. To mitigate this problem, clients can obtain an {@linkplain MemorySession#implicit() obtain}
+ * might result in memory leaks. To mitigate this problem, clients can {@linkplain MemorySession#implicit() obtain}
  * bounded memory sessions that are managed implicitly, by the garbage collector. These sessions end at some unspecified
  * time <em>after</em> they become <a href="../../../java/lang/ref/package.html#reachability">unreachable</a>, as shown below:
  *
@@ -60,7 +60,7 @@
  * segment = null; // the session might end after this instruction
  *}
  *
- * Bounded sessions that are managed implicitly can be useful to manage long-lived segments, where timely deallocation
+ * Bounded sessions that are managed implicitly can be useful to allocate long-lived segments, where timely deallocation
  * is not critical, or in unstructured cases where the boundaries of the lifetime associated with a memory session
  * cannot be easily determined. As shown in the example above, a memory session that is managed implicitly cannot end
  * if a program references to one or more segments associated with that session. This means that memory segments associated

test/micro/org/openjdk/bench/java/lang/foreign/StrLenTest.java

@@ -159,7 +159,8 @@ public MemorySegment allocate(long byteSize, long byteAlignment) {
                 reset();
             }
             MemorySegment res = current.allocate(byteSize, byteAlignment);
-            rem = segment.byteSize() - segment.segmentOffset(res);
+            long lastOffset = segment.segmentOffset(res) + res.byteSize();
+            rem = segment.byteSize() - lastOffset;
             return res;
         }