add auto arena to SwiftKit core that should work on Android

Author: madsodgaard

Samples/JExtractJNISampleApp/src/main/java/com/example/swift/HelloJava2SwiftJNI.java

@@ -18,8 +18,8 @@
 
 // Import javakit/swiftkit support libraries
 
+import org.swift.swiftkit.core.SwiftArena;
 import org.swift.swiftkit.core.SwiftLibraries;
-import org.swift.swiftkit.core.ConfinedSwiftMemorySession;
 
 public class HelloJava2SwiftJNI {
 
@@ -41,7 +41,7 @@ static void examples() {
 
         MySwiftClass.method();
 
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass myClass = MySwiftClass.init(10, 5, arena);
             MySwiftClass myClass2 = MySwiftClass.init(arena);
 

Samples/JExtractJNISampleApp/src/test/java/com/example/swift/MySwiftClassTest.java

@@ -15,7 +15,7 @@
 package com.example.swift;
 
 import org.junit.jupiter.api.Test;
-import org.swift.swiftkit.core.ConfinedSwiftMemorySession;
+import org.swift.swiftkit.core.SwiftArena;
 
 import java.util.Optional;
 import java.util.OptionalInt;
@@ -26,39 +26,39 @@
 public class MySwiftClassTest {
     @Test
     void init_noParameters() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(arena);
             assertNotNull(c);
         }
     }
 
     @Test
     void init_withParameters() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(1337, 42, arena);
             assertNotNull(c);
         }
     }
 
     @Test
     void sum() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(20, 10, arena);
             assertEquals(30, c.sum());
         }
     }
 
     @Test
     void xMultiplied() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(20, 10, arena);
             assertEquals(200, c.xMultiplied(10));
         }
     }
 
     @Test
     void throwingFunction() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(20, 10, arena);
             Exception exception = assertThrows(Exception.class, () -> c.throwingFunction());
 
@@ -68,15 +68,15 @@ void throwingFunction() {
 
     @Test
     void constant() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(20, 10, arena);
             assertEquals(100, c.getConstant());
         }
     }
 
     @Test
     void mutable() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(20, 10, arena);
             assertEquals(0, c.getMutable());
             c.setMutable(42);
@@ -86,15 +86,15 @@ void mutable() {
 
     @Test
     void product() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(20, 10, arena);
             assertEquals(200, c.getProduct());
         }
     }
 
     @Test
     void throwingVariable() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(20, 10, arena);
 
             Exception exception = assertThrows(Exception.class, () -> c.getThrowingVariable());
@@ -105,7 +105,7 @@ void throwingVariable() {
 
     @Test
     void mutableDividedByTwo() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(20, 10, arena);
             assertEquals(0, c.getMutableDividedByTwo());
             c.setMutable(20);
@@ -117,15 +117,15 @@ void mutableDividedByTwo() {
 
     @Test
     void isWarm() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(20, 10, arena);
             assertFalse(c.isWarm());
         }
     }
 
     @Test
     void sumWithX() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c1 = MySwiftClass.init(20, 10, arena);
             MySwiftClass c2 = MySwiftClass.init(50, 10, arena);
             assertEquals(70, c1.sumX(c2));
@@ -134,7 +134,7 @@ void sumWithX() {
 
     @Test
     void copy() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c1 = MySwiftClass.init(20, 10, arena);
             MySwiftClass c2 = c1.copy(arena);
 
@@ -146,7 +146,7 @@ void copy() {
 
     @Test
     void addXWithJavaLong() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c1 = MySwiftClass.init(20, 10, arena);
             Long javaLong = 50L;
             assertEquals(70, c1.addXWithJavaLong(javaLong));

Samples/JExtractJNISampleApp/src/test/java/com/example/swift/MySwiftStructTest.java

@@ -16,13 +16,14 @@
 
 import org.junit.jupiter.api.Test;
 import org.swift.swiftkit.core.ConfinedSwiftMemorySession;
+import org.swift.swiftkit.core.SwiftArena;
 
 import static org.junit.jupiter.api.Assertions.*;
 
 public class MySwiftStructTest {
     @Test
     void init() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftStruct s = MySwiftStruct.init(1337, 42, arena);
             assertEquals(1337, s.getCapacity());
             assertEquals(42, s.getLen());
@@ -31,7 +32,7 @@ void init() {
 
     @Test
     void getAndSetLen() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftStruct s = MySwiftStruct.init(1337, 42, arena);
             s.setLen(100);
             assertEquals(100, s.getLen());
@@ -40,7 +41,7 @@ void getAndSetLen() {
 
     @Test
     void increaseCap() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftStruct s = MySwiftStruct.init(1337, 42, arena);
             long newCap = s.increaseCap(10);
             assertEquals(1347, newCap);

Samples/JExtractJNISampleApp/src/test/java/com/example/swift/OptionalsTest.java

@@ -15,7 +15,7 @@
 package com.example.swift;
 
 import org.junit.jupiter.api.Test;
-import org.swift.swiftkit.core.ConfinedSwiftMemorySession;
+import org.swift.swiftkit.core.SwiftArena;
 
 import java.util.Optional;
 import java.util.OptionalDouble;
@@ -82,7 +82,7 @@ void optionalString() {
 
     @Test
     void optionalClass() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(arena);
             assertEquals(Optional.empty(), MySwiftLibrary.optionalClass(Optional.empty(), arena));
             Optional<MySwiftClass> optionalClass = MySwiftLibrary.optionalClass(Optional.of(c), arena);
@@ -99,7 +99,7 @@ void optionalJavaKitLong() {
 
     @Test
     void multipleOptionals() {
-        try (var arena = new ConfinedSwiftMemorySession()) {
+        try (var arena = SwiftArena.ofConfined()) {
             MySwiftClass c = MySwiftClass.init(arena);
             OptionalLong result = MySwiftLibrary.multipleOptionals(
                     Optional.of((byte) 1),

SwiftKitCore/src/main/java/org/swift/swiftkit/core/AutoSwiftMemorySession.java

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+package org.swift.swiftkit.core;
+
+
+import org.swift.swiftkit.core.ref.Cleaner;
+
+import java.util.Objects;
+import java.util.concurrent.ThreadFactory;
+
+/**
+ * A memory session which manages registered objects via the Garbage Collector.
+ *
+ * <p> When registered Java wrapper classes around native Swift instances {@link SwiftInstance},
+ * are eligible for collection, this will trigger the cleanup of the native resources as well.
+ *
+ * <p> This memory session is LESS reliable than using a {@link ConfinedSwiftMemorySession} because
+ * the timing of when the native resources are cleaned up is somewhat undefined, and rely on the
+ * system GC. Meaning, that if an object nas been promoted to an old generation, there may be a
+ * long time between the resource no longer being referenced "in Java" and its native memory being released,
+ * and also the deinit of the Swift type being run.
+ *
+ * <p> This can be problematic for Swift applications which rely on quick release of resources, and may expect
+ * the deinits to run in expected and "quick" succession.
+ *
+ * <p> Whenever possible, prefer using an explicitly managed {@link SwiftArena}, such as {@link SwiftArena#ofConfined()}.
+ */
+final class AutoSwiftMemorySession implements SwiftArena {
+    private final Cleaner cleaner;
+
+    public AutoSwiftMemorySession(ThreadFactory cleanerThreadFactory) {
+        this.cleaner = Cleaner.create(cleanerThreadFactory);
+    }
+
+    @Override
+    public void register(SwiftInstance instance) {
+        Objects.requireNonNull(instance, "value");
+
+        // We make sure we don't capture `instance` in the
+        // cleanup action, so we can ignore the warning below.
+        var cleanupAction = instance.$createCleanup();
+        cleaner.register(instance, cleanupAction);
+    }
+}

SwiftKitCore/src/main/java/org/swift/swiftkit/core/ConfinedSwiftMemorySession.java

@@ -28,17 +28,13 @@ public class ConfinedSwiftMemorySession implements ClosableSwiftArena {
 
     final ConfinedResourceList resources;
 
-    public ConfinedSwiftMemorySession() {
-        this(Thread.currentThread());
-    }
-
     public ConfinedSwiftMemorySession(Thread owner) {
         this.owner = owner;
         this.state = new AtomicInteger(ACTIVE);
         this.resources = new ConfinedResourceList();
     }
 
-    public void checkValid() throws RuntimeException {
+    void checkValid() throws RuntimeException {
         if (this.owner != null && this.owner != Thread.currentThread()) {
             throw new WrongThreadException(String.format("ConfinedSwift arena is confined to %s but was closed from %s!", this.owner, Thread.currentThread()));
         } else if (this.state.get() < ACTIVE) {

SwiftKitCore/src/main/java/org/swift/swiftkit/core/JNISwiftInstance.java

@@ -56,13 +56,8 @@ protected JNISwiftInstance(long selfPointer, SwiftArena arena) {
 
     @Override
     public SwiftInstanceCleanup $createCleanup() {
-        final AtomicBoolean statusDestroyedFlag = $statusDestroyedFlag();
-        Runnable markAsDestroyed = new Runnable() {
-            @Override
-            public void run() {
-                statusDestroyedFlag.set(true);
-            }
-        };
+        var statusDestroyedFlag = $statusDestroyedFlag();
+        Runnable markAsDestroyed = () -> statusDestroyedFlag.set(true);
 
         return new JNISwiftInstanceCleanup(this.$createDestroyFunction(), markAsDestroyed);
     }

SwiftKitCore/src/main/java/org/swift/swiftkit/core/SwiftArena.java

@@ -14,6 +14,8 @@
 
 package org.swift.swiftkit.core;
 
+import java.util.concurrent.ThreadFactory;
+
 /**
  * A Swift arena manages Swift allocated memory for classes, structs, enums etc.
  * When an arena is closed, it will destroy all managed swift objects in a way appropriate to their type.
@@ -27,6 +29,15 @@ public interface SwiftArena  {
      * Its memory should be considered managed by this arena, and be destroyed when the arena is closed.
      */
     void register(SwiftInstance instance);
+
+    static ClosableSwiftArena ofConfined() {
+        return new ConfinedSwiftMemorySession(Thread.currentThread());
+    }
+
+    static SwiftArena ofAuto() {
+        ThreadFactory cleanerThreadFactory = r -> new Thread(r, "AutoSwiftArenaCleanerThread");
+        return new AutoSwiftMemorySession(cleanerThreadFactory);
+    }
 }
 
 /**

SwiftKitCore/src/main/java/org/swift/swiftkit/core/ref/Cleaner.java

@@ -0,0 +1,51 @@
+package org.swift.swiftkit.core.ref;
+
+import java.lang.ref.ReferenceQueue;
+import java.util.LinkedList;
+import java.util.Objects;
+import java.util.concurrent.ThreadFactory;
+
+public class Cleaner implements Runnable {
+    final ReferenceQueue<Object> referenceQueue;
+    final LinkedList<PhantomCleanable> list;
+
+    private Cleaner() {
+        this.referenceQueue = new ReferenceQueue<>();
+        this.list = new LinkedList<>();
+    }
+
+    public static Cleaner create(ThreadFactory threadFactory) {
+        Cleaner cleaner = new Cleaner();
+        cleaner.start(threadFactory);
+        return cleaner;
+    }
+
+    void start(ThreadFactory threadFactory) {
+        // This makes sure the linked list is not empty when the thread starts,
+        // and the thread will run at least until the cleaner itself can be GCed.
+        new PhantomCleanable(this, this, () -> {});
+
+        Thread thread = threadFactory.newThread(this);
+        thread.setDaemon(true);
+        thread.start();
+    }
+
+    public void register(Object resourceHolder, Runnable cleaningAction) {
+        Objects.requireNonNull(resourceHolder, "resourceHolder");
+        Objects.requireNonNull(cleaningAction, "cleaningAction");
+        new PhantomCleanable(resourceHolder, this, cleaningAction);
+    }
+
+    @Override
+    public void run() {
+        while (!list.isEmpty()) {
+            try {
+                PhantomCleanable removed = (PhantomCleanable) referenceQueue.remove(60 * 1000L);
+                removed.cleanup();
+            } catch (Throwable e) {
+                // ignore exceptions from the cleanup action
+                // (including interruption of cleanup thread)
+            }
+        }
+    }
+}