Free heap-space (hires models) if the renderer didnt use it for more than one minute

Author: TBlueF

core/src/main/java/de/bluecolored/bluemap/core/map/hires/ArrayTileModel.java

@@ -30,13 +30,30 @@
 import de.bluecolored.bluemap.core.util.math.MatrixM3f;
 import de.bluecolored.bluemap.core.util.math.MatrixM4f;
 
+import java.time.Duration;
+import java.time.Instant;
+
 public class ArrayTileModel implements TileModel {
-    private static final double GROW_MULTIPLIER = 1.5;
+    private static final float GROW_MULTIPLIER = 1.5f;
     private static final int MAX_CAPACITY = 1000000;
 
+    private static final float SHRINK_MULTIPLIER = 1 / GROW_MULTIPLIER;
+    private static final Duration SHRINK_TIME = Duration.ofMinutes(1);
+
     private static final InstancePool<ArrayTileModel> INSTANCE_POOL = new InstancePool<>(
             () -> new ArrayTileModel(100),
-            ArrayTileModel::clear
+            model -> {
+                Instant now = Instant.now();
+
+                if ((float) model.size / model.capacity > SHRINK_MULTIPLIER)
+                    model.lastCapacityUse = now;
+                else if (model.lastCapacityUse.plus(SHRINK_TIME).isBefore(now))
+                    return null; // drop model
+
+                model.clear();
+                return model;
+            },
+            Duration.ofMinutes(1)
     );
 
     // attributes         per-vertex * per-face
@@ -57,6 +74,8 @@ public class ArrayTileModel implements TileModel {
     byte[] sunlight, blocklight;
     int[] materialIndex, materialIndexSort, materialIndexSortSupport;
 
+    private transient Instant lastCapacityUse = Instant.now();
+
     public ArrayTileModel(int initialCapacity) {
         if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity is negative");
         setCapacity(initialCapacity);

core/src/main/java/de/bluecolored/bluemap/core/util/InstancePool.java

@@ -24,38 +24,75 @@
  */
 package de.bluecolored.bluemap.core.util;
 
+import de.bluecolored.bluemap.core.logger.Logger;
+import org.jetbrains.annotations.Nullable;
+
+import java.time.Duration;
+import java.util.Timer;
+import java.util.TimerTask;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
 public class InstancePool<T> {
 
+    private static final class AutoClearTimer {
+        private static final Timer INSTANCE = new Timer("BlueMap-InstancePool-RecycleTimer", true);
+    }
+
     private final Supplier<T> creator;
     private final Function<T, T> recycler;
     private final ConcurrentLinkedQueue<T> pool = new ConcurrentLinkedQueue<>();
+    private final @Nullable Duration autoClearTime;
+    private @Nullable TimerTask autoClearTask = null;
 
     public InstancePool(Supplier<T> creator) {
         this.creator = creator;
         this.recycler = t -> t;
+        this.autoClearTime = null;
     }
 
     public InstancePool(Supplier<T> creator, Function<T, T> recycler) {
         this.creator = creator;
         this.recycler = recycler;
+        this.autoClearTime = null;
+    }
+
+    public InstancePool(Supplier<T> creator, Function<T, T> recycler, @Nullable Duration autoClearTime) {
+        this.creator = creator;
+        this.recycler = recycler;
+        this.autoClearTime = autoClearTime;
+        updateAutoClear();
+    }
+
+    private void updateAutoClear() {
+        if (autoClearTask != null) autoClearTask.cancel();
+        if (autoClearTime != null) {
+            autoClearTask = new TimerTask() {
+                @Override
+                public void run() {
+                    Logger.global.logInfo("Auto-clearing pool now!");
+                    InstancePool.this.clear();
+                }
+            };
+            AutoClearTimer.INSTANCE.schedule(autoClearTask, autoClearTime.toMillis());
+        }
     }
 
     public T claimInstance() {
         T instance = pool.poll();
         if (instance == null) {
             instance = creator.get();
         }
+        updateAutoClear();
         return instance;
     }
 
     public void recycleInstance(T instance) {
         instance = recycler.apply(instance);
         if (instance != null)
             pool.offer(instance);
+        updateAutoClear();
     }
 
     public void clear() {