Implement SwiftValue cleanup

Author: ktoso

SwiftKit/src/main/java/org/swift/swiftkit/AutoSwiftMemorySession.java

@@ -14,6 +14,7 @@
 
 package org.swift.swiftkit;
 
+import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
 import java.lang.ref.Cleaner;
 import java.util.Objects;
@@ -38,15 +39,24 @@
  */
 final class AutoSwiftMemorySession implements SwiftArena {
 
+    private final Arena arena;
     private final Cleaner cleaner;
 
     public AutoSwiftMemorySession(ThreadFactory cleanerThreadFactory) {
         this.cleaner = Cleaner.create(cleanerThreadFactory);
+        this.arena = Arena.ofAuto();
     }
 
     @Override
     public void register(SwiftHeapObject object) {
-        SwiftHeapObjectCleanup cleanupAction = new SwiftHeapObjectCleanup(object.$memorySegment(), object.$swiftType());
+        var statusDestroyedFlag = object.$statusDestroyedFlag();
+        Runnable markAsDestroyed = () -> statusDestroyedFlag.set(true);
+
+        SwiftHeapObjectCleanup cleanupAction = new SwiftHeapObjectCleanup(
+                object.$memorySegment(),
+                object.$swiftType(),
+                markAsDestroyed
+        );
         register(object, cleanupAction);
     }
 
@@ -62,9 +72,18 @@ void register(SwiftHeapObject object, SwiftHeapObjectCleanup cleanupAction) {
     @Override
     public void register(SwiftValue value) {
         Objects.requireNonNull(value, "value");
+
+        // We're doing this dance to avoid keeping a strong reference to the value itself
+        var statusDestroyedFlag = value.$statusDestroyedFlag();
+        Runnable markAsDestroyed = () -> statusDestroyedFlag.set(true);
+
         MemorySegment resource = value.$memorySegment();
-        var cleanupAction = new SwiftValueCleanup(resource);
+        var cleanupAction = new SwiftValueCleanup(resource, value.$swiftType(), markAsDestroyed);
         cleaner.register(value, cleanupAction);
     }
 
+    @Override
+    public MemorySegment allocate(long byteSize, long byteAlignment) {
+        return arena.allocate(byteSize, byteAlignment);
+    }
 }

SwiftKit/src/main/java/org/swift/swiftkit/ConfinedSwiftMemorySession.java

@@ -14,6 +14,8 @@
 
 package org.swift.swiftkit;
 
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -26,12 +28,15 @@ final class ConfinedSwiftMemorySession implements ClosableSwiftArena {
     final Thread owner;
     final AtomicInteger state;
 
+    final Arena arena;
     final ConfinedResourceList resources;
 
     public ConfinedSwiftMemorySession(Thread owner) {
         this.owner = owner;
         this.state = new AtomicInteger(ACTIVE);
         this.resources = new ConfinedResourceList();
+
+        this.arena = Arena.ofConfined();
     }
 
     public void checkValid() throws RuntimeException {
@@ -51,24 +56,42 @@ public void close() {
         if (this.state.compareAndExchange(ACTIVE, CLOSED) == ACTIVE) {
             this.resources.runCleanup();
         } // else, was already closed; do nothing
+
+        this.arena.close();
     }
 
     @Override
     public void register(SwiftHeapObject object) {
         checkValid();
 
-        var cleanup = new SwiftHeapObjectCleanup(object.$memorySegment(), object.$swiftType());
+        var statusDestroyedFlag = object.$statusDestroyedFlag();
+        Runnable markAsDestroyed = () -> statusDestroyedFlag.set(true);
+
+        var cleanup = new SwiftHeapObjectCleanup(
+                object.$memorySegment(), object.$swiftType(),
+                markAsDestroyed);
         this.resources.add(cleanup);
     }
 
     @Override
     public void register(SwiftValue value) {
         checkValid();
 
-        var cleanup = new SwiftValueCleanup(value.$memorySegment());
+        var statusDestroyedFlag = value.$statusDestroyedFlag();
+        Runnable markAsDestroyed = () -> statusDestroyedFlag.set(true);
+
+        var cleanup = new SwiftValueCleanup(
+                value.$memorySegment(),
+                value.$swiftType(),
+                markAsDestroyed);
         this.resources.add(cleanup);
     }
 
+    @Override
+    public MemorySegment allocate(long byteSize, long byteAlignment) {
+        return arena.allocate(byteSize, byteAlignment);
+    }
+
     static final class ConfinedResourceList implements SwiftResourceList {
         // TODO: Could use intrusive linked list to avoid one indirection here
         final List<SwiftInstanceCleanup> resourceCleanups = new LinkedList<>();
@@ -82,6 +105,7 @@ public void runCleanup() {
             for (SwiftInstanceCleanup cleanup : resourceCleanups) {
                 cleanup.run();
             }
+            resourceCleanups.clear();
         }
     }
 }

SwiftKit/src/main/java/org/swift/swiftkit/SwiftAnyType.java

@@ -56,11 +56,19 @@ public SwiftAnyType(SwiftHeapObject object) {
         return $LAYOUT;
     }
 
+    /**
+     * Get the human-readable Swift type name of this type.
+     */
+    public String getSwiftName() {
+        return SwiftKit.nameOfSwiftType(memorySegment, true);
+    }
+
     @Override
     public String toString() {
         return "AnySwiftType{" +
-                "name=" + SwiftKit.nameOfSwiftType(memorySegment, true) +
+                "name=" + getSwiftName() +
                 ", memorySegment=" + memorySegment +
                 '}';
     }
+
 }

SwiftKit/src/main/java/org/swift/swiftkit/SwiftInstanceCleanup.java

@@ -31,18 +31,21 @@ interface SwiftInstanceCleanup extends Runnable {
 // non-final for testing
 class SwiftHeapObjectCleanup implements SwiftInstanceCleanup {
 
-    final MemorySegment selfPointer;
-    final SwiftAnyType selfType;
+    private final MemorySegment selfPointer;
+    private final SwiftAnyType selfType;
+    private final Runnable markAsDestroyed;
 
     /**
      * This constructor on purpose does not just take a {@link SwiftHeapObject} in order to make it very
      * clear that it does not take ownership of it, but we ONLY manage the native resource here.
-     *
+     * </p>
      * This is important for {@link AutoSwiftMemorySession} which relies on the wrapper type to be GC-able,
      * when no longer "in use" on the Java side.
      */
-    SwiftHeapObjectCleanup(MemorySegment selfPointer, SwiftAnyType selfType) {
+    SwiftHeapObjectCleanup(MemorySegment selfPointer,
+                           SwiftAnyType selfType, Runnable markAsDestroyed) {
         this.selfPointer  = selfPointer;
+        this.markAsDestroyed = markAsDestroyed;
         this.selfType = selfType;
     }
 
@@ -54,6 +57,8 @@ public void run() throws UnexpectedRetainCountException {
             throw new UnexpectedRetainCountException(selfPointer, retainedCount, 1);
         }
 
+        this.markAsDestroyed.run();
+
         // Destroy (and deinit) the object:
         SwiftValueWitnessTable.destroy(selfType, selfPointer);
 
@@ -62,9 +67,17 @@ public void run() throws UnexpectedRetainCountException {
     }
 }
 
-record SwiftValueCleanup(MemorySegment resource) implements SwiftInstanceCleanup {
+record SwiftValueCleanup(
+        MemorySegment selfPointer,
+        SwiftAnyType selfType,
+        Runnable markAsDestroyed
+) implements SwiftInstanceCleanup {
+
     @Override
     public void run() {
-        throw new RuntimeException("not implemented yet");
+        System.out.println("[debug] Destroy swift value [" + selfType.getSwiftName() + "]: " + selfPointer);
+
+        markAsDestroyed.run();
+        SwiftValueWitnessTable.destroy(selfType, selfPointer);
     }
 }