Merge branch 'debugging-cleaner'

Author: luka-leko

.idea/misc.xml

@@ -0,0 +1,16 @@
+/*
+ Copyright 2026 JKU/Dynatrace Co-Innovation Lab
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+package com.dynatrace.vectorscan4j;

src/main/java/com/dynatrace/vectorscan4j/CallHandlerOnMatch.java

@@ -51,7 +51,6 @@
  */
 public class Database implements AutoCloseable {
     private static final Cleaner CLEANER = Cleaner.create();
-
     private final Arena arena;
     protected final MemorySegment dbNative;
     protected final int modeNative;
@@ -91,7 +90,7 @@ public void run() {
      *     offending pattern id and vectorscan's error description)
      */
     public Database(List<Expression> expressions, ExecutionMode executionMode) {
-        this.arena = Arena.ofConfined();
+        this.arena = Arena.ofShared();
         this.expressions = List.copyOf(expressions);
         this.mode = executionMode;
         this.modeNative = executionMode.equals(ExecutionMode.BLOCK_MODE) ? 1 : 2 + (1 << 24);
@@ -226,7 +225,7 @@ public static Database deserialize(InputStream is) {
             MemorySegment dbBytesPtr = temp.allocate(dbBytes.length);
             dbBytesPtr.asByteBuffer().put(dbBytes);
 
-            Arena arena = Arena.ofConfined();
+            Arena arena = Arena.ofShared();
             try {
                 MemorySegment dbPtr = arena.allocate(C_POINTER);
                 int ans = hs_deserialize_database(dbBytesPtr, dbBytes.length, dbPtr);

src/main/java/com/dynatrace/vectorscan4j/Database.java

@@ -30,20 +30,29 @@
 
 abstract class Scanner implements AutoCloseable {
     private static final Cleaner CLEANER = Cleaner.create();
-
     private long bufferCapacity = 1024L; // 1KB default buffer size
     private int bufferLength;
-    private Arena dataArena = Arena.ofConfined();
+    private Arena dataArena = Arena.ofShared();
     private MemorySegment dataSegment = dataArena.allocate(bufferCapacity);
-    protected final Arena arena = Arena.ofConfined();
+    protected final Arena arena = Arena.ofShared();
     protected final Database database;
-    private OnMatchEventHandler handler;
     protected final MemorySegment scratch;
-    protected final MemorySegment funcPtr = VectorscanMatchEventHandler.allocate(new CallHandlerOnMatch(), arena);
-    private final CleanupState cleanupState;
+    private final CallHandlerOnMatch callHandler = new CallHandlerOnMatch();
+    protected MemorySegment funcPtr = VectorscanMatchEventHandler.allocate(callHandler, arena);
+    ;
+    protected final CleanupState cleanupState;
     private final Cleaner.Cleanable cleanable;
 
-    private static final class CleanupState implements Runnable {
+    static class CallHandlerOnMatch implements VectorscanMatchEventHandler.Function {
+        OnMatchEventHandler handler;
+
+        @Override
+        public int apply(int id, long from, long to, int flags, MemorySegment context) {
+            return handler.onMatch(id, from, to, flags) ? 0 : 1;
+        }
+    }
+
+    protected static final class CleanupState implements Runnable {
         private final MemorySegment scratch;
         private final Arena arena; // manages lifetime of internal scratch space.
         private Arena dataArena; // manages lifetime of internal data segment.
@@ -76,17 +85,12 @@ public void run() {
     }
 
     protected void setHandler(OnMatchEventHandler handler) {
-        this.handler = handler;
-    }
-
-    protected class CallHandlerOnMatch implements VectorscanMatchEventHandler.Function {
-        @Override
-        public int apply(int id, long from, long to, int flags, MemorySegment context) {
-            return handler.onMatch(id, from, to, flags) ? 0 : 1;
-        }
+        this.callHandler.handler = handler;
     }
 
     protected Scanner(Database database) {
+        CallHandlerOnMatch callHandler = new CallHandlerOnMatch();
+
         this.database = database;
 
         // allocate scratch space
@@ -117,7 +121,7 @@ protected void setBuffer(ByteBuffer input) {
 
     private void resizeBuffer(long newSize) {
         dataArena.close();
-        dataArena = Arena.ofConfined();
+        dataArena = Arena.ofShared();
         cleanupState.setDataArena(dataArena);
         dataSegment = dataArena.allocate(newSize);
         bufferCapacity = newSize;

src/main/java/com/dynatrace/vectorscan4j/Scanner.java

@@ -26,6 +26,7 @@
 import com.dynatrace.vectorscan4j.utils.LoadGenerator;
 import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
+import java.lang.ref.WeakReference;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
@@ -393,4 +394,53 @@ void scannerOperationsWithInvalidDb() {
             db.dbNative.set(JAVA_BYTE, 0, b0);
         }
     }
+
+    @Test
+    void notClosingStillFreesMemory() throws InterruptedException {
+        Database db = new Database(expressions, BLOCK_MODE);
+        BlockScanner scanner = new BlockScanner(db);
+        WeakReference<Database> dbRef = new WeakReference<>(db);
+        WeakReference<BlockScanner> scannerRef = new WeakReference<>(scanner);
+        assertNotNull(dbRef.get(), "Database was freed pre-emptively.");
+        assertNotNull(scannerRef.get(), "BlockScanner was freed pre-emptively.");
+
+        // Making the BlockScanner instance unreachable will garbage collect that instance, but not the Database
+        scanner = null;
+        System.gc();
+        Thread.sleep(100);
+        assertNotNull(dbRef.get(), "Database was freed pre-emptively.");
+        assertNull(scannerRef.get(), "Scanner did not get freed.");
+
+        // Making the Database instance unreachable will then also free the Database.
+        db = null;
+        System.gc();
+        Thread.sleep(100);
+        assertNull(dbRef.get(), "Database did not get freed.");
+        assertNull(scannerRef.get(), "Scanner did not get freed.");
+    }
+
+    @Test
+    void scannerKeepsDatabaseAlive() throws InterruptedException {
+        Database db = new Database(expressions, BLOCK_MODE);
+        BlockScanner scanner = new BlockScanner(db);
+        WeakReference<Database> dbRef = new WeakReference<>(db);
+        WeakReference<BlockScanner> scannerRef = new WeakReference<>(scanner);
+        assertNotNull(dbRef.get(), "Database was freed pre-emptively.");
+        assertNotNull(scannerRef.get(), "BlockScanner was freed pre-emptively.");
+
+        // The BlockScanner keeps the Database alive, so it won't get garbage collected.
+        db = null;
+        System.gc();
+        Thread.sleep(100);
+        assertNotNull(dbRef.get(), "Database was freed pre-emptively.");
+        assertNotNull(scannerRef.get(), "Scanner was freed pre-emptively.");
+
+        // Also losing the strong reference to the BlockScanner will cascade the freeing operation to the Database
+        scanner = null;
+        System.gc();
+        Thread.sleep(100);
+
+        assertNull(dbRef.get(), "Database did not get freed.");
+        assertNull(scannerRef.get(), "Scanner did not get freed.");
+    }
 }

src/test/java/com/dynatrace/vectorscan4j/BlockScannerTests.java

@@ -25,6 +25,7 @@
 import com.dynatrace.vectorscan4j.constants.ExecutionMode;
 import com.dynatrace.vectorscan4j.constants.Flags;
 import java.io.*;
+import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.EnumSet;
@@ -297,4 +298,16 @@ void operationsOnInvalidDb() {
             assertDoesNotThrow(() -> db.serialize());
         }
     }
+
+    @Test
+    void notClosingStillFreesMemory() throws InterruptedException {
+        Database db = new Database(expressions, BLOCK_MODE);
+        WeakReference<Database> dbRef = new WeakReference<>(db);
+        assertNotNull(dbRef.get(), "Database was freed pre-emptively.");
+        db = null;
+
+        System.gc();
+        Thread.sleep(100);
+        assertNull(dbRef.get(), "Database did not get freed.");
+    }
 }