Various performance optimizations

sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongeBootstrap.java

@@ -30,8 +30,8 @@ import com.google.inject.Inject;
 import me.lucko.luckperms.api.platform.PlatformType;
 import me.lucko.luckperms.common.dependencies.classloader.PluginClassLoader;
 import me.lucko.luckperms.common.dependencies.classloader.ReflectionClassLoader;
-import me.lucko.luckperms.common.plugin.SchedulerAdapter;
 import me.lucko.luckperms.common.plugin.bootstrap.LuckPermsBootstrap;
+import me.lucko.luckperms.common.plugin.scheduler.SchedulerAdapter;
 import me.lucko.luckperms.common.utils.MoreFiles;
 import me.lucko.luckperms.sponge.utils.VersionData;
 

sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java

@@ -28,7 +28,7 @@ package me.lucko.luckperms.sponge;
 import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.LuckPermsApi;
 import me.lucko.luckperms.common.api.LuckPermsApiProvider;
-import me.lucko.luckperms.common.calculators.PlatformCalculatorFactory;
+import me.lucko.luckperms.common.calculators.CalculatorFactory;
 import me.lucko.luckperms.common.command.CommandManager;
 import me.lucko.luckperms.common.command.abstraction.Command;
 import me.lucko.luckperms.common.command.access.CommandPermission;
@@ -75,6 +75,7 @@ import java.util.EnumSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Stream;
 
 /**
@@ -146,7 +147,7 @@ public class LPSpongePlugin extends AbstractLuckPermsPlugin {
     }
 
     @Override
-    protected PlatformCalculatorFactory provideCalculatorFactory() {
+    protected CalculatorFactory provideCalculatorFactory() {
         return new SpongeCalculatorFactory(this);
     }
 
@@ -189,9 +190,9 @@ public class LPSpongePlugin extends AbstractLuckPermsPlugin {
 
     @Override
     protected void registerHousekeepingTasks() {
-        this.bootstrap.getScheduler().asyncRepeating(new ExpireTemporaryTask(this), 60L);
-        this.bootstrap.getScheduler().asyncRepeating(new CacheHousekeepingTask(this), 2400L);
-        this.bootstrap.getScheduler().asyncRepeating(new ServiceCacheHousekeepingTask(this.service), 2400L);
+        this.bootstrap.getScheduler().asyncRepeating(new ExpireTemporaryTask(this), 3, TimeUnit.SECONDS);
+        this.bootstrap.getScheduler().asyncRepeating(new CacheHousekeepingTask(this), 2, TimeUnit.MINUTES);
+        this.bootstrap.getScheduler().asyncRepeating(new ServiceCacheHousekeepingTask(this.service), 2, TimeUnit.MINUTES);
     }
 
     @Override

sponge/src/main/java/me/lucko/luckperms/sponge/SpongeSchedulerAdapter.java

@@ -25,17 +25,19 @@
 
 package me.lucko.luckperms.sponge;
 
-import me.lucko.luckperms.common.plugin.SchedulerAdapter;
 import me.lucko.luckperms.common.plugin.SchedulerTask;
+import me.lucko.luckperms.common.plugin.scheduler.SchedulerAdapter;
 import me.lucko.luckperms.common.utils.Iterators;
 
 import org.spongepowered.api.scheduler.Scheduler;
 import org.spongepowered.api.scheduler.SpongeExecutorService;
 import org.spongepowered.api.scheduler.Task;
 
+import java.util.Collections;
 import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.WeakHashMap;
 import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
 
 public class SpongeSchedulerAdapter implements SchedulerAdapter {
     private final LPSpongeBootstrap bootstrap;
@@ -44,7 +46,7 @@ public class SpongeSchedulerAdapter implements SchedulerAdapter {
     private final SpongeExecutorService sync;
     private final SpongeExecutorService async;
     
-    private final Set<SchedulerTask> tasks = ConcurrentHashMap.newKeySet();
+    private final Set<Task> tasks = Collections.newSetFromMap(new WeakHashMap<>());
 
     public SpongeSchedulerAdapter(LPSpongeBootstrap bootstrap, Scheduler scheduler, SpongeExecutorService sync, SpongeExecutorService async) {
         this.bootstrap = bootstrap;
@@ -64,82 +66,43 @@ public class SpongeSchedulerAdapter implements SchedulerAdapter {
     }
 
     @Override
-    public void doAsync(Runnable runnable) {
+    public void executeAsync(Runnable runnable) {
         this.scheduler.createTaskBuilder().async().execute(runnable).submit(this.bootstrap);
     }
 
     @Override
-    public void doSync(Runnable runnable) {
+    public void executeSync(Runnable runnable) {
         this.scheduler.createTaskBuilder().execute(runnable).submit(this.bootstrap);
     }
 
     @Override
-    public SchedulerTask asyncRepeating(Runnable runnable, long intervalTicks) {
-        Task task = this.scheduler.createTaskBuilder()
+    public SchedulerTask asyncLater(Runnable task, long delay, TimeUnit unit) {
+        Task t = this.scheduler.createTaskBuilder()
                 .async()
-                .intervalTicks(intervalTicks)
-                .delayTicks(intervalTicks)
-                .execute(runnable)
+                .delay(delay, unit)
+                .execute(task)
                 .submit(this.bootstrap);
 
-        SchedulerTask wrapped = new SpongeSchedulerTask(task);
-        this.tasks.add(wrapped);
-        return wrapped;
+        this.tasks.add(t);
+        return t::cancel;
     }
 
     @Override
-    public SchedulerTask syncRepeating(Runnable runnable, long intervalTicks) {
-        Task task = this.scheduler.createTaskBuilder()
-                .intervalTicks(intervalTicks)
-                .delayTicks(intervalTicks)
-                .execute(runnable)
-                .submit(this.bootstrap);
-
-        SchedulerTask wrapped = new SpongeSchedulerTask(task);
-        this.tasks.add(wrapped);
-        return wrapped;
-    }
-
-    @Override
-    public SchedulerTask asyncLater(Runnable runnable, long delayTicks) {
-        Task task = this.scheduler.createTaskBuilder()
+    public SchedulerTask asyncRepeating(Runnable task, long interval, TimeUnit unit) {
+        Task t = this.scheduler.createTaskBuilder()
                 .async()
-                .delayTicks(delayTicks)
-                .execute(runnable)
+                .interval(interval, unit)
+                .delay(interval, unit)
+                .execute(task)
                 .submit(this.bootstrap);
 
-        SchedulerTask wrapped = new SpongeSchedulerTask(task);
-        this.tasks.add(wrapped);
-        return wrapped;
-    }
-
-    @Override
-    public SchedulerTask syncLater(Runnable runnable, long delayTicks) {
-        Task task = this.scheduler.createTaskBuilder()
-                .delayTicks(delayTicks)
-                .execute(runnable)
-                .submit(this.bootstrap);
-
-        SchedulerTask wrapped = new SpongeSchedulerTask(task);
-        this.tasks.add(wrapped);
-        return wrapped;
+        this.tasks.add(t);
+        return t::cancel;
     }
 
     @Override
     public void shutdown() {
-        Iterators.iterate(this.tasks, SchedulerTask::cancel);
+        Iterators.iterate(this.tasks, Task::cancel);
     }
 
-    private static final class SpongeSchedulerTask implements SchedulerTask {
-        private final Task task;
-
-        private SpongeSchedulerTask(Task task) {
-            this.task = task;
-        }
-
-        @Override
-        public void cancel() {
-            this.task.cancel();
-        }
-    }
 }

sponge/src/main/java/me/lucko/luckperms/sponge/calculators/SpongeCalculatorFactory.java

@@ -28,7 +28,7 @@ package me.lucko.luckperms.sponge.calculators;
 import com.google.common.collect.ImmutableList;
 
 import me.lucko.luckperms.api.Contexts;
-import me.lucko.luckperms.common.calculators.AbstractCalculatorFactory;
+import me.lucko.luckperms.common.calculators.CalculatorFactory;
 import me.lucko.luckperms.common.calculators.PermissionCalculator;
 import me.lucko.luckperms.common.calculators.PermissionCalculatorMetadata;
 import me.lucko.luckperms.common.config.ConfigKeys;
@@ -41,7 +41,7 @@ import me.lucko.luckperms.sponge.processors.GroupDefaultsProcessor;
 import me.lucko.luckperms.sponge.processors.SpongeWildcardProcessor;
 import me.lucko.luckperms.sponge.processors.UserDefaultsProcessor;
 
-public class SpongeCalculatorFactory extends AbstractCalculatorFactory {
+public class SpongeCalculatorFactory implements CalculatorFactory {
     private final LPSpongePlugin plugin;
 
     public SpongeCalculatorFactory(LPSpongePlugin plugin) {
@@ -74,6 +74,6 @@ public class SpongeCalculatorFactory extends AbstractCalculatorFactory {
             }
         }
 
-        return registerCalculator(new PermissionCalculator(this.plugin, metadata, processors.build()));
+        return new PermissionCalculator(this.plugin, metadata, processors.build());
     }
 }

sponge/src/main/java/me/lucko/luckperms/sponge/listeners/SpongeConnectionListener.java

@@ -165,7 +165,7 @@ public class SpongeConnectionListener extends AbstractConnectionListener {
         this.plugin.getUserManager().getHouseKeeper().registerUsage(player.getUniqueId());
 
         // force a clear of transient nodes
-        this.plugin.getBootstrap().getScheduler().doAsync(() -> {
+        this.plugin.getBootstrap().getScheduler().executeAsync(() -> {
             User user = this.plugin.getUserManager().getIfLoaded(player.getUniqueId());
             if (user != null) {
                 user.clearTransientNodes();

sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java

@@ -237,8 +237,6 @@ public class LuckPermsService implements LPPermissionService {
                 subject.invalidateCaches();
             }
         }
-
-        this.plugin.getCalculatorFactory().invalidateAll();
     }
 
 }

sponge/src/main/java/me/lucko/luckperms/sponge/service/event/UpdateEventHandlerImpl.java

@@ -39,7 +39,7 @@ public class UpdateEventHandlerImpl implements UpdateEventHandler {
 
     @Override
     public void fireUpdateEvent(LPSubjectData subjectData) {
-        this.plugin.getBootstrap().getScheduler().doAsync(() -> {
+        this.plugin.getBootstrap().getScheduler().executeAsync(() -> {
             SubjectDataUpdateEvent event = new LPSubjectDataUpdateEvent(this.plugin, subjectData);
             this.plugin.getBootstrap().getGame().getEventManager().post(event);
         });

sponge/src/main/java/me/lucko/luckperms/sponge/service/internal/HolderSubject.java

@@ -161,7 +161,7 @@ public abstract class HolderSubject<T extends PermissionHolder> implements LPSub
     @Override
     public void invalidateCaches() {
         // invalidate for all changes
-        this.parent.getCachedData().invalidate();
+        this.parent.invalidateCachedData();
     }
 
 }

sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/SubjectDataContainer.java

@@ -35,7 +35,6 @@ import com.google.gson.JsonObject;
 import me.lucko.luckperms.api.context.ImmutableContextSet;
 import me.lucko.luckperms.common.contexts.ContextSetComparator;
 import me.lucko.luckperms.common.contexts.ContextSetJsonSerializer;
-import me.lucko.luckperms.common.utils.CollationKeyCache;
 import me.lucko.luckperms.sponge.service.calculated.CalculatedSubjectData;
 import me.lucko.luckperms.sponge.service.model.LPPermissionService;
 import me.lucko.luckperms.sponge.service.model.LPSubjectData;
@@ -204,7 +203,7 @@ public class SubjectDataContainer {
 
             // sort alphabetically.
             List<Map.Entry<String, Boolean>> perms = new ArrayList<>(e.getValue().entrySet());
-            perms.sort(Map.Entry.comparingByKey(CollationKeyCache.comparator()));
+            perms.sort(Map.Entry.comparingByKey());
 
             for (Map.Entry<String, Boolean> ent : perms) {
                 data.addProperty(ent.getKey(), ent.getValue());
@@ -228,7 +227,7 @@ public class SubjectDataContainer {
 
             // sort alphabetically.
             List<Map.Entry<String, String>> opts = new ArrayList<>(e.getValue().entrySet());
-            opts.sort(Map.Entry.comparingByKey(CollationKeyCache.comparator()));
+            opts.sort(Map.Entry.comparingByKey());
 
             for (Map.Entry<String, String> ent : opts) {
                 data.addProperty(ent.getKey(), ent.getValue());