OpenSource/PaperMC
OpenSource/PaperMC
1
0
Fork 0
mirror of https://github.com/PaperMC/Paper.git synced 2024-12-30 16:19:03 +01:00
Code Issues Projects Releases Packages Wiki Activity
PaperMC/Spigot-Server-Patches/Auto-Save-Improvements.patch

225 lines
11 KiB
Diff
Raw Normal View History

Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Aikar <aikar@aikar.co>
Date: Mon, 19 Sep 2016 23:16:39 -0400
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
Subject: [PATCH] Auto Save Improvements
Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used.
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
Adds incremental player auto saving too
diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
Add max-player-auto-save-per-tick setting to spread out saves more This will force the saves to spread over multiple ticks even when many players auto save interval is aligned, avoiding spikes on large servers. Closes #1021
2018-03-05 02:20:27 +01:00
index 621c585e7..459c86bce 100644
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
--- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
@@ -0,0 +0,0 @@ public class PaperConfig {
flyingKickPlayerMessage = getString("messages.kick.flying-player", flyingKickPlayerMessage);
flyingKickVehicleMessage = getString("messages.kick.flying-vehicle", flyingKickVehicleMessage);
}
+
+ public static int playerAutoSaveRate = -1;
Add max-player-auto-save-per-tick setting to spread out saves more This will force the saves to spread over multiple ticks even when many players auto save interval is aligned, avoiding spikes on large servers. Closes #1021
2018-03-05 02:20:27 +01:00
+ public static int maxPlayerAutoSavePerTick = 10;
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
+ private static void playerAutoSaveRate() {
+ playerAutoSaveRate = getInt("settings.player-auto-save-rate", -1);
Add max-player-auto-save-per-tick setting to spread out saves more This will force the saves to spread over multiple ticks even when many players auto save interval is aligned, avoiding spikes on large servers. Closes #1021
2018-03-05 02:20:27 +01:00
+ maxPlayerAutoSavePerTick = getInt("settings.max-player-auto-save-per-tick", -1);
+ if (maxPlayerAutoSavePerTick == -1) { // -1 Automatic / "Recommended"
+ // 10 should be safe for everyone unless your mass spamming player auto save
+ maxPlayerAutoSavePerTick = (playerAutoSaveRate == -1 || playerAutoSaveRate > 100) ? 10 : 20;
+ }
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
+ }
}
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
Added options to disable additional ore generation in Mesa and Extreme Hills (#1006)
2018-02-13 01:44:50 +01:00
index d182e716a..d1655de42 100644
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
@@ -0,0 +0,0 @@ package com.destroystokyo.paper;
import java.util.List;
+import net.minecraft.server.MinecraftServer;
import org.bukkit.configuration.file.YamlConfiguration;
import org.spigotmc.SpigotWorldConfig;
Update to MC 1.12-pre2
2017-05-14 20:05:01 +02:00
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
@@ -0,0 +0,0 @@ public class PaperWorldConfig {
private void elytraHitWallDamage() {
elytraHitWallDamage = getBoolean("elytra-hit-wall-damage", true);
}
+
+ public int autoSavePeriod = -1;
+ private void autoSavePeriod() {
+ autoSavePeriod = getInt("auto-save-interval", -1);
+ if (autoSavePeriod > 0) {
+ log("Auto Save Interval: " +autoSavePeriod + " (" + (autoSavePeriod / 20) + "s)");
+ } else if (autoSavePeriod < 0) {
+ autoSavePeriod = MinecraftServer.getServer().autosavePeriod;
+ }
+ }
+
+ public int maxAutoSaveChunksPerTick = 24;
+ private void maxAutoSaveChunksPerTick() {
+ maxAutoSaveChunksPerTick = getInt("max-auto-save-chunks-per-tick", 24);
+ }
}
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java
Update B/CB
2018-01-24 18:31:43 +01:00
index 8ec26b97c..87730aec3 100644
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
--- a/src/main/java/net/minecraft/server/Chunk.java
+++ b/src/main/java/net/minecraft/server/Chunk.java
@@ -0,0 +0,0 @@ public class Chunk {
if (this.t && this.world.getTime() != this.lastSaved || this.s) {
return true;
}
- } else if (this.t && this.world.getTime() >= this.lastSaved + MinecraftServer.getServer().autosavePeriod * 4) { // Spigot - Only save if we've passed 2 auto save intervals without modification
Fix faulty logic in Auto Save check - Fixes #443
2016-11-04 06:31:49 +01:00
- return true;
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
}
Fix faulty logic in Auto Save check - Fixes #443
2016-11-04 06:31:49 +01:00
-
- return this.s;
+ // This !flag section should say if s(isModified) or t(hasEntities), then check auto save
+ return ((this.s || this.t) && this.world.getTime() >= this.lastSaved + world.paperConfig.autoSavePeriod); // Paper - Make world configurable and incremental
}
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
Fix faulty logic in Auto Save check - Fixes #443
2016-11-04 06:31:49 +01:00
public Random a(long i) {
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java
Update B/CB
2018-01-24 18:31:43 +01:00
index 0adfcaa8b..9e8f67ffd 100644
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
--- a/src/main/java/net/minecraft/server/ChunkProviderServer.java
+++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
@@ -0,0 +0,0 @@
package net.minecraft.server;
+import com.destroystokyo.paper.PaperConfig;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
@@ -0,0 +0,0 @@ public class ChunkProviderServer implements IChunkProvider {
Update S
2017-08-12 23:32:01 +02:00
this.saveChunk(chunk, false); // Spigot
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
chunk.f(false);
++i;
- if (i == 24 && !flag && false) { // Spigot
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
+ if (!flag && i >= world.paperConfig.maxAutoSaveChunksPerTick) { // Spigot - // Paper - Incremental Auto Save - cap max per tick
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
return false;
}
}
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
diff --git a/src/main/java/net/minecraft/server/EntityPlayer.java b/src/main/java/net/minecraft/server/EntityPlayer.java
Update CB/S
2018-03-31 11:34:25 +02:00
index 2391adac7..8b7eb47a2 100644
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
--- a/src/main/java/net/minecraft/server/EntityPlayer.java
+++ b/src/main/java/net/minecraft/server/EntityPlayer.java
@@ -0,0 +0,0 @@ public class EntityPlayer extends EntityHuman implements ICrafting {
Update Paper to MC 1.12-pre5
2017-05-21 06:41:39 +02:00
private static final Logger bV = LogManager.getLogger();
Update upstream B/CB/S
2017-05-28 06:25:17 +02:00
public String locale = null; // PAIL: private -> public // Paper - default to null
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
+ public long lastSave = MinecraftServer.currentTick; // Paper
public PlayerConnection playerConnection;
public final MinecraftServer server;
public final PlayerInteractManager playerInteractManager;
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
Update B/CB
2018-01-24 18:31:43 +01:00
index ab7933079..5c09c6ff7 100644
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
Update to MC 1.12-pre2
2017-05-14 20:05:01 +02:00
@@ -0,0 +0,0 @@ public abstract class MinecraftServer implements ICommandListener, Runnable, IAs
don't save level every tick for auto save. whoops
2016-09-26 07:50:26 +02:00
public final Thread primaryThread;
public java.util.Queue<Runnable> processQueue = new java.util.concurrent.ConcurrentLinkedQueue<Runnable>();
public int autosavePeriod;
+ public boolean serverAutoSave = false; // Paper
// CraftBukkit end
Update upstream S
2017-01-31 05:33:54 +01:00
// Spigot start
public final SlackActivityAccountant slackActivityAccountant = new SlackActivityAccountant();
Update to MC 1.12-pre2
2017-05-14 20:05:01 +02:00
@@ -0,0 +0,0 @@ public abstract class MinecraftServer implements ICommandListener, Runnable, IAs
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
this.q.b().a(agameprofile);
}
- if (autosavePeriod > 0 && this.ticks % autosavePeriod == 0) { // CraftBukkit
this.methodProfiler.a("save");
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
- this.v.savePlayers();
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
+
don't save level every tick for auto save. whoops
2016-09-26 07:50:26 +02:00
+ serverAutoSave = (autosavePeriod > 0 && this.ticks % autosavePeriod == 0); // Paper
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
+ int playerSaveInterval = com.destroystokyo.paper.PaperConfig.playerAutoSaveRate;
+ if (playerSaveInterval < 0) {
+ playerSaveInterval = autosavePeriod;
+ }
+ if (playerSaveInterval > 0) { // CraftBukkit // Paper
+ this.v.savePlayers(playerSaveInterval);
Don't save players every tick, oops
2016-09-20 05:39:21 +02:00
// Spigot Start
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
+ } // Paper - Incremental Auto Saving
+
Don't save players every tick, oops
2016-09-20 05:39:21 +02:00
// We replace this with saving each individual world as this.saveChunks(...) is broken,
// and causes the main thread to sleep for random amounts of time depending on chunk activity
Auto Save Improvements Makes Auto Save Rate setting configurable per-world. If the auto save rate is left -1, the global bukkit.yml value will be used. Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once. Re-introduce a cap per tick for auto save (Spigot disabled the vanilla cap) and make it configurable.
2016-09-22 04:12:56 +02:00
// Also pass flag to only save modified chunks
server.playerCommandState = true;
for (World world : worlds) {
- world.getWorld().save(false);
+ if (world.paperConfig.autoSavePeriod > 0) world.getWorld().save(false); // Paper - Incremental / Configurable Auto Saving
}
server.playerCommandState = false;
// this.saveChunks(true);
// Spigot End
this.methodProfiler.b();
- }
+ //} // Paper - Incremental Auto Saving
this.methodProfiler.a("tallying");
Update upstream S
2017-01-31 05:33:54 +01:00
// Spigot start
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java
Update CB/S
2018-03-31 11:34:25 +02:00
index 3fc242e4b..90f6e2e04 100644
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
--- a/src/main/java/net/minecraft/server/PlayerList.java
+++ b/src/main/java/net/minecraft/server/PlayerList.java
@@ -0,0 +0,0 @@ public abstract class PlayerList {
}
protected void savePlayerFile(EntityPlayer entityplayer) {
+ entityplayer.lastSave = MinecraftServer.currentTick; // Paper
this.playerFileData.save(entityplayer);
Update upstream (memory leak fix)
2017-07-17 02:36:27 +02:00
ServerStatisticManager serverstatisticmanager = (ServerStatisticManager) entityplayer.getStatisticManager(); // CraftBukkit
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
@@ -0,0 +0,0 @@ public abstract class PlayerList {
}
+ // Paper start
public void savePlayers() {
+ savePlayers(null);
+ }
+
+ public void savePlayers(Integer interval) {
+ long now = MinecraftServer.currentTick;
MinecraftTimings.savePlayers.startTiming(); // Paper
Add max-player-auto-save-per-tick setting to spread out saves more This will force the saves to spread over multiple ticks even when many players auto save interval is aligned, avoiding spikes on large servers. Closes #1021
2018-03-05 02:20:27 +01:00
+ int numSaved = 0; // Paper
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
for (int i = 0; i < this.players.size(); ++i) {
- this.savePlayerFile((EntityPlayer) this.players.get(i));
+ EntityPlayer entityplayer = this.players.get(i);
+ if (interval == null || now - entityplayer.lastSave >= interval) {
+ this.savePlayerFile(entityplayer);
Add max-player-auto-save-per-tick setting to spread out saves more This will force the saves to spread over multiple ticks even when many players auto save interval is aligned, avoiding spikes on large servers. Closes #1021
2018-03-05 02:20:27 +01:00
+ if (interval != null && ++numSaved <= com.destroystokyo.paper.PaperConfig.maxPlayerAutoSavePerTick) { break; } // Paper
Incremental Auto Save Players Take same approach we did for chunks, and only save player if its been X time since last save, instead of doing it all in 1 tick. This is even more helpful considering Player Saving is done sync for File IO.
2016-12-27 22:11:25 +01:00
+ }
}
MinecraftTimings.savePlayers.stopTiming(); // Paper
}
+ // Paper end
public void addWhitelist(GameProfile gameprofile) {
this.whitelist.add(new WhiteListEntry(gameprofile));
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java
Update B/CB
2018-01-24 18:31:43 +01:00
index f2ddc22dd..8493dccee 100644
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
--- a/src/main/java/net/minecraft/server/WorldServer.java
+++ b/src/main/java/net/minecraft/server/WorldServer.java
@@ -0,0 +0,0 @@ public class WorldServer extends World implements IAsyncTaskHandler {
ChunkProviderServer chunkproviderserver = this.getChunkProviderServer();
if (chunkproviderserver.e()) {
- org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld())); // CraftBukkit
+ if (flag) org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld())); // CraftBukkit // Paper - Incremental Auto Saving - Only fire event on full save
Properly update patches for upstream merge
2016-10-21 22:42:49 +02:00
timings.worldSave.startTiming(); // Paper
+ if (flag || server.serverAutoSave) { // Paper
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
if (iprogressupdate != null) {
iprogressupdate.a("Saving level");
}
Properly update patches for upstream merge
2016-10-21 22:42:49 +02:00
@@ -0,0 +0,0 @@ public class WorldServer extends World implements IAsyncTaskHandler {
don't save level every tick for auto save. whoops
2016-09-26 07:50:26 +02:00
if (iprogressupdate != null) {
iprogressupdate.c("Saving chunks");
}
Properly update patches for upstream merge
2016-10-21 22:42:49 +02:00
+ } // Paper
timings.worldSaveChunks.startTiming(); // Paper
chunkproviderserver.a(flag);
Incremental Auto Saving Process auto save every tick instead of once per auto tick interval, so that chunk saves will distribute over many ticks instead of all at once.
2016-09-20 05:31:42 +02:00
--
Reference in a new issue Copy permalink