RocksDbStatistics class
Пакет: com.hypixel.hytale.server.core.universe.world.storage.provider
Файл: com/hypixel/hytale/server/core/universe/world/storage/provider/RocksDbChunkStorageProvider.java
implements: MetricProvider
Поля (12)
| Модификаторы | Тип | Имя |
|---|---|---|
|
public static final MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStatistics> |
METRICS_REGISTRY |
|
public static final MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot> |
METRICS_REGISTRY |
|
public final RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot[] |
histograms |
|
public final long[] |
tickers |
|
MetricsRegistry |
var0 |
|
|
var0 |
|
|
var0 |
|
long[] |
var1 |
|
int |
var2 |
|
MemorySegment |
var3 |
|
int |
var4 |
|
RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot[] |
var8 |
Методы (9)
| Модификаторы | Возврат | Сигнатура |
|---|---|---|
|
private static MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStatistics> |
buildRegistryprivate static MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStatistics> buildRegistry() |
|
|
for for(int var2 = 0; var2 < RocksDbNative.STATISTICS_TICKERS.length; var2++) |
|
|
for for(int var4 = 0; var4 < RocksDbNative.STATISTICS_HISTOGRAMS.length; var4++) |
|
|
for for(int var1 = 0; var1 < RocksDbNative.STATISTICS_TICKERS.length; var1++) |
|
|
for for(int var3 = 0; var3 < RocksDbNative.STATISTICS_HISTOGRAMS.length; var3++) |
|
public static RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot |
frompublic static RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot from(@Nonnull MemorySegment var0) |
|
public static RocksDbChunkStorageProvider.RocksDbStatistics |
snapshotpublic static RocksDbChunkStorageProvider.RocksDbStatistics snapshot(@Nonnull MemorySegment var0) |
|
public MetricResults |
toMetricResultspublic MetricResults toMetricResults() |
|
public MetricResults |
toMetricResultspublic MetricResults toMetricResults() |
Исходный код
Показать/скрыть
class="kw">package com.hypixel.hytale.server.core.universe.world.storage.provider;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.component.ComponentRegistry;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.lib.rocksdb.RocksDbNative;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.metrics.BucketedOpStats;
class="kw">import com.hypixel.hytale.metrics.MetricProvider;
class="kw">import com.hypixel.hytale.metrics.MetricResults;
class="kw">import com.hypixel.hytale.metrics.MetricsRegistry;
class="kw">import com.hypixel.hytale.server.core.entity.Dirty;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockComponentChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.ChunkColumn;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.ChunkFlag;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.EntityChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockComponentSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.ChunkSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.EntitySection;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.IChunkLoader;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.IChunkSaver;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.component.ChunkSavingSystems;
class="kw">import com.hypixel.hytale.server.core.util.BsonUtil;
class="kw">import com.hypixel.hytale.server.core.util.io.FileUtil;
class="kw">import com.hypixel.hytale.server.core.util.io.MemorySegmentUtil;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import it.unimi.dsi.fastutil.longs.LongArrayList;
class="kw">import it.unimi.dsi.fastutil.longs.LongList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectListIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ReferenceArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.shorts.ShortArrayList;
class="kw">import it.unimi.dsi.fastutil.shorts.ShortIterator;
class="kw">import it.unimi.dsi.fastutil.shorts.ShortOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.shorts.ShortSet;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ObjectMap.Entry;
class="kw">import java.io.IOException;
class="kw">import java.lang.foreign.Arena;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import java.lang.foreign.ValueLayout;
class="kw">import java.nio.ByteBuffer;
class="kw">import java.util.Arrays;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.Executor;
class="kw">import java.util.concurrent.ExecutorService;
class="kw">import java.util.concurrent.Executors;
class="kw">import java.util.concurrent.ForkJoinPool;
class="kw">import java.util.concurrent.RejectedExecutionException;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.concurrent.atomic.AtomicInteger;
class="kw">import java.util.concurrent.atomic.AtomicLong;
class="kw">import java.util.function.BiConsumer;
class="kw">import java.util.function.IntFunction;
class="kw">import java.util.function.Supplier;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.bson.BsonDocument;
class="kw">import org.bson.io.BasicOutputBuffer;
class="kw">import org.checkerframework.checker.nullness.compatqual.NonNullDecl;
class="kw">public class RocksDbChunkStorageProvider class="kw">implements IChunkStorageProvider<RocksDbChunkStorageProvider.RocksDbResource> {
@Nonnull
class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
class="kw">public class="kw">static class="kw">final String ID = "RocksDb";
class="kw">public class="kw">static class="kw">final BuilderCodec<RocksDbChunkStorageProvider> CODEC = BuilderCodec.builder(
RocksDbChunkStorageProvider.class, RocksDbChunkStorageProvider::new
)
.build();
class="kw">public class="kw">static class="kw">final String STATISTICS_PROPERTY = "hytale.rocksdb.stats";
class="kw">public class="kw">static class="kw">final String BLOB_GC_AGE_CUTOFF_PROPERTY = "hytale.rocksdb.blob_gc_age_cutoff";
class="kw">public class="kw">static class="kw">final String BLOB_GC_FORCE_THRESHOLD_PROPERTY = "hytale.rocksdb.blob_gc_force_threshold";
class="kw">public class="kw">static class="kw">final String BLOB_COMPACTION_READAHEAD_SIZE_PROPERTY = "hytale.rocksdb.blob_compaction_readahead_size";
class="kw">public class="kw">static class="kw">final String MIN_BLOB_SIZE_PROPERTY = "hytale.rocksdb.min_blob_size";
class="kw">public class="kw">static class="kw">final String BLOB_CACHE_SIZE_PROPERTY = "hytale.rocksdb.blob_cache_size";
class="kw">public class="kw">static class="kw">final String IO_THREADS_PROPERTY = "hytale.rocksdb.io_threads";
class="kw">private class="kw">static class="kw">final double BLOB_GC_AGE_CUTOFF = parseDoubleProperty("hytale.rocksdb.blob_gc_age_cutoff", 0.25);
class="kw">private class="kw">static class="kw">final double BLOB_GC_FORCE_THRESHOLD = parseDoubleProperty("hytale.rocksdb.blob_gc_force_threshold", 0.75);
class="kw">private class="kw">static class="kw">final long BLOB_COMPACTION_READAHEAD_BYTES = parseLongProperty("hytale.rocksdb.blob_compaction_readahead_size", 2097152L);
class="kw">private class="kw">static class="kw">final long MIN_BLOB_SIZE_BYTES = parseLongProperty("hytale.rocksdb.min_blob_size", 4096L);
class="kw">private class="kw">static class="kw">final long BLOCK_CACHE_BYTES = 134217728L;
class="kw">private class="kw">static class="kw">final long BLOB_CACHE_BYTES = parseLongProperty("hytale.rocksdb.blob_cache_size", 0L);
class="kw">private class="kw">static class="kw">final long CHUNK_LEVEL_COMPACTION_BUDGET = 33554432L;
class="kw">private class="kw">static class="kw">final long SECTION_LEVEL_COMPACTION_BUDGET = 67108864L;
class="kw">private class="kw">static class="kw">final long ENTITY_SECTION_LEVEL_COMPACTION_BUDGET = 8388608L;
class="kw">private class="kw">static class="kw">final long ENTITY_LEVEL_COMPACTION_BUDGET = 16777216L;
class="kw">private class="kw">static class="kw">final long BLOCK_COMPONENT_LEVEL_COMPACTION_BUDGET = 8388608L;
class="kw">private class="kw">static class="kw">final double BLOOM_BITS_PER_KEY = 9.9;
class="kw">private class="kw">static class="kw">final int IO_THREADS = Math.max(1, parseIntProperty("hytale.rocksdb.io_threads", 4));
class="kw">private class="kw">static class="kw">final AtomicInteger IO_THREAD_COUNTER = new AtomicInteger();
class="kw">private class="kw">static class="kw">final int CHUNK_KEY_BYTES = 8;
class="kw">private class="kw">static class="kw">final int SECTION_KEY_BYTES = 12;
class="kw">private class="kw">static class="kw">final int ENTITY_KEY_BYTES = 16;
class="kw">private class="kw">static class="kw">final int BLOCK_COMPONENT_KEY_BYTES = 14;
class="kw">private class="kw">static class="kw">final long MAX_ENTITIES_PER_SECTION = 65536L;
class="kw">private class="kw">static class="kw">final long MAX_ROW_BYTES = 268435456L;
class="kw">private class="kw">static class="kw">final ThreadLocal<RocksDbChunkStorageProvider.Scratch> SCRATCH = ThreadLocal.withInitial(RocksDbChunkStorageProvider.Scratch::new);
class="kw">public RocksDbChunkStorageProvider() {
}
@Nullable
class="kw">private class="kw">static String rawProperty(@Nonnull String var0) {
String var1 = System.getProperty(var0);
class="kw">return var1 != null && !var1.isBlank() ? var1.trim() : null;
}
class="kw">private class="kw">static double parseDoubleProperty(@Nonnull String var0, double var1) {
String var3 = rawProperty(var0);
class="kw">return var3 == null ? var1 : Double.parseDouble(var3);
}
class="kw">private class="kw">static long parseLongProperty(@Nonnull String var0, long var1) {
String var3 = rawProperty(var0);
class="kw">return var3 == null ? var1 : Long.parseLong(var3);
}
class="kw">private class="kw">static int parseIntProperty(@Nonnull String var0, int var1) {
String var2 = rawProperty(var0);
class="kw">return var2 == null ? var1 : Integer.parseInt(var2);
}
class="kw">public RocksDbChunkStorageProvider.RocksDbResource initialize(@NonNullDecl Store<ChunkStore> var1) class="kw">throws IOException {
RocksDbChunkStorageProvider.RocksDbResource var2 = new RocksDbChunkStorageProvider.RocksDbResource();
var2.statisticsEnabled = Boolean.getBoolean("hytale.rocksdb.stats");
MemorySegment var3 = RocksDbNative.cacheCreateLru(134217728L);
var2.blockCache = var3;
MemorySegment var4 = BLOB_CACHE_BYTES > 0L ? RocksDbNative.cacheCreateLru(BLOB_CACHE_BYTES) : MemorySegment.NULL;
var2.blobCache = var4;
MemorySegment var5 = RocksDbNative.optionsCreate();
var2.options = var5;
RocksDbNative.optionsSetCreateIfMissing(var5, true);
RocksDbNative.optionsSetCreateMissingColumnFamilies(var5, true);
RocksDbNative.optionsIncreaseParallelism(var5, ForkJoinPool.getCommonPoolParallelism());
RocksDbNative.optionsSetMaxTotalWalSize(var5, 536870912L);
if (var2.statisticsEnabled) {
RocksDbNative.optionsEnableStatistics(var5);
}
MemorySegment var6 = buildDefaultColumnOptions(var3);
MemorySegment var7 = buildColumnOptions(var3, var4, 33554432L, 8, true);
MemorySegment var8 = buildColumnOptions(var3, var4, 67108864L, 12, true);
MemorySegment var9 = buildColumnOptions(var3, var4, 8388608L, 12, false);
MemorySegment var10 = buildColumnOptions(var3, var4, 16777216L, 16, true);
MemorySegment var11 = buildColumnOptions(var3, var4, 8388608L, 12, true);
try (Arena var12 = Arena.ofConfined()) {
String[] var13 = new String[]{"class="kw">default", "chunks", "sections", "entity_sections", "entities", "block_components"};
MemorySegment[] var14 = new MemorySegment[]{var6, var7, var8, var9, var10, var11};
int var15 = var13.length;
MemorySegment var16 = var12.allocate(RocksDbNative.C_POINTER, var15);
MemorySegment var17 = var12.allocate(RocksDbNative.C_POINTER, var15);
MemorySegment var18 = var12.allocate(RocksDbNative.C_POINTER, var15);
for (int var19 = 0; var19 < var15; var19++) {
var16.setAtIndex(RocksDbNative.C_POINTER, var19, var12.allocateFrom(var13[var19]));
var17.setAtIndex(RocksDbNative.C_POINTER, var19, var14[var19]);
}
MemorySegment var30 = var12.allocate(RocksDbNative.C_POINTER);
var30.set(RocksDbNative.C_POINTER, 0L, MemorySegment.NULL);
MemorySegment var20 = var12.allocateFrom(String.valueOf(var1.getExternalData().getWorld().getSavePath().resolve("db")));
MemorySegment var21 = RocksDbNative.openColumnFamilies(var5, var20, var15, var16, var17, var18, var30);
String var22 = RocksDbNative.consumeError(var30);
if (var22 != null) {
RocksDbNative.optionsDestroy(var5);
RocksDbNative.cacheDestroy(var3);
if (!var4.equals(MemorySegment.NULL)) {
RocksDbNative.cacheDestroy(var4);
}
throw new RocksDbChunkStorageProvider.RocksDbException("Failed to open RocksDB: " + var22);
}
var2.db = var21;
var2.chunkColumn = var18.getAtIndex(RocksDbNative.C_POINTER, 1L);
var2.sectionColumn = var18.getAtIndex(RocksDbNative.C_POINTER, 2L);
var2.entitySectionColumn = var18.getAtIndex(RocksDbNative.C_POINTER, 3L);
var2.entityColumn = var18.getAtIndex(RocksDbNative.C_POINTER, 4L);
var2.blockComponentColumn = var18.getAtIndex(RocksDbNative.C_POINTER, 5L);
RocksDbNative.columnFamilyHandleDestroy(var18.getAtIndex(RocksDbNative.C_POINTER, 0L));
} class="kw">finally {
RocksDbNative.optionsDestroy(var6);
RocksDbNative.optionsDestroy(var7);
RocksDbNative.optionsDestroy(var8);
RocksDbNative.optionsDestroy(var9);
RocksDbNative.optionsDestroy(var10);
RocksDbNative.optionsDestroy(var11);
}
var2.writeOptions = RocksDbNative.writeoptionsCreate();
var2.readOptions = RocksDbNative.readoptionsCreate();
var2.flushOptions = RocksDbNative.flushoptionsCreate();
RocksDbNative.flushoptionsSetWait(var2.flushOptions, true);
var2.ioExecutor = Executors.newFixedThreadPool(IO_THREADS, var0 -> {
Runnable var1 = () -> {
try {
var0.run();
} class="kw">finally {
SCRATCH.get().destroy();
SCRATCH.remove();
}
};
Thread var2 = new Thread(var1, "rocksdb-io-" + IO_THREAD_COUNTER.getAndIncrement());
var2.setDaemon(true);
class="kw">return var2;
});
class="kw">return var2;
}
@Nonnull
class="kw">private class="kw">static MemorySegment buildColumnOptions(@Nonnull MemorySegment var0, @Nonnull MemorySegment var1, long var2, int var4, boolean var5) {
MemorySegment var6 = RocksDbNative.blockBasedOptionsCreate();
RocksDbNative.blockBasedOptionsSetBlockCache(var6, var0);
RocksDbNative.blockBasedOptionsSetIndexType(var6, 1);
RocksDbNative.blockBasedOptionsSetFilterPolicy(var6, RocksDbNative.filterpolicyCreateBloomFull(9.9));
RocksDbNative.blockBasedOptionsSetOptimizeFiltersForMemory(var6, true);
MemorySegment var7 = RocksDbNative.optionsCreate();
RocksDbNative.optionsSetCompression(var7, 4);
RocksDbNative.optionsSetBottommostCompression(var7, 7);
RocksDbNative.optionsSetBlockBasedTableFactory(var7, var6);
RocksDbNative.blockBasedOptionsDestroy(var6);
RocksDbNative.optionsSetCompactionStyle(var7, 0);
RocksDbNative.optionsOptimizeLevelStyleCompaction(var7, var2);
RocksDbNative.optionsSetLevelCompactionDynamicLevelBytes(var7, true);
RocksDbNative.optionsSetCompactionPri(var7, 3);
RocksDbNative.optionsSetPrefixExtractor(var7, RocksDbNative.slicetransformCreateFixedPrefix(var4));
if (var5) {
RocksDbNative.optionsSetEnableBlobFiles(var7, true);
RocksDbNative.optionsSetEnableBlobGc(var7, true);
RocksDbNative.optionsSetBlobCompactionReadaheadSize(var7, BLOB_COMPACTION_READAHEAD_BYTES);
RocksDbNative.optionsSetMinBlobSize(var7, MIN_BLOB_SIZE_BYTES);
RocksDbNative.optionsSetBlobGcAgeCutoff(var7, BLOB_GC_AGE_CUTOFF);
RocksDbNative.optionsSetBlobGcForceThreshold(var7, BLOB_GC_FORCE_THRESHOLD);
RocksDbNative.optionsSetBlobCompressionType(var7, 7);
if (!var1.equals(MemorySegment.NULL)) {
RocksDbNative.optionsSetBlobCache(var7, var1);
}
}
class="kw">return var7;
}
@Nonnull
class="kw">private class="kw">static MemorySegment buildDefaultColumnOptions(@Nonnull MemorySegment var0) {
MemorySegment var1 = RocksDbNative.blockBasedOptionsCreate();
RocksDbNative.blockBasedOptionsSetBlockCache(var1, var0);
MemorySegment var2 = RocksDbNative.optionsCreate();
RocksDbNative.optionsSetBlockBasedTableFactory(var2, var1);
RocksDbNative.blockBasedOptionsDestroy(var1);
class="kw">return var2;
}
class="kw">private class="kw">static void checkError(@Nonnull MemorySegment var0) {
String var1 = RocksDbNative.consumeError(var0);
if (var1 != null) {
throw new RocksDbChunkStorageProvider.RocksDbException(var1);
}
}
class="kw">public void delete(@Nonnull RocksDbChunkStorageProvider.RocksDbResource var1, @Nonnull Store<ChunkStore> var2) class="kw">throws IOException {
if (!this.closeInternal(var1)) {
LOGGER.at(Level.WARNING).log("RocksDB teardown was abandoned; skipping db directory removal to avoid a use-after-free");
} else {
FileUtil.deleteDirectory(var2.getExternalData().getWorld().getSavePath().resolve("db"));
}
}
class="kw">private class="kw">static boolean drainIoExecutor(@Nonnull ExecutorService var0) {
try {
if (var0.awaitTermination(30L, TimeUnit.SECONDS)) {
class="kw">return true;
}
var0.shutdownNow();
class="kw">return var0.awaitTermination(30L, TimeUnit.SECONDS);
} catch (InterruptedException var5) {
var0.shutdownNow();
boolean var2 = false;
try {
var2 = var0.awaitTermination(30L, TimeUnit.SECONDS);
} catch (InterruptedException var4) {
}
Thread.currentThread().interrupt();
class="kw">return var2;
}
}
class="kw">private class="kw">static void failPendingIo(@Nonnull RocksDbChunkStorageProvider.RocksDbResource var0) {
List var1 = List.copyOf(var0.inFlightIo);
if (!var1.isEmpty()) {
LOGGER.at(Level.WARNING)
.log("Completing %d in-flight RocksDB I/O future(s) exceptionally during teardown so joiners fail fast instead of hanging", var1.size());
IOException var2 = new IOException("RocksDB storage closed before this I/O task completed");
for (CompletableFuture var4 : var1) {
var4.completeExceptionally(var2);
}
}
}
class="kw">public void close(@NonNullDecl RocksDbChunkStorageProvider.RocksDbResource var1, @NonNullDecl Store<ChunkStore> var2) class="kw">throws IOException {
this.closeInternal(var1);
}
class="kw">private boolean closeInternal(@Nonnull RocksDbChunkStorageProvider.RocksDbResource var1) {
if (var1.db == null) {
class="kw">return true;
}
if (var1.ioExecutor != null) {
RocksDbNative.disableManualCompaction(var1.db);
var1.ioExecutor.shutdown();
boolean var2 = drainIoExecutor(var1.ioExecutor);
failPendingIo(var1);
if (!var2) {
LOGGER.at(Level.WARNING).log("RocksDB I/O executor did not terminate; leaking class="kw">native handles to avoid a use-after-free during teardown");
class="kw">return false;
}
}
try (Arena var12 = Arena.ofConfined()) {
MemorySegment var3 = var12.allocate(RocksDbNative.C_POINTER);
var3.set(RocksDbNative.C_POINTER, 0L, MemorySegment.NULL);
RocksDbNative.flushWal(var1.db, true, var3);
checkError(var3);
} class="kw">finally {
RocksDbNative.columnFamilyHandleDestroy(var1.chunkColumn);
RocksDbNative.columnFamilyHandleDestroy(var1.sectionColumn);
RocksDbNative.columnFamilyHandleDestroy(var1.entitySectionColumn);
RocksDbNative.columnFamilyHandleDestroy(var1.entityColumn);
RocksDbNative.columnFamilyHandleDestroy(var1.blockComponentColumn);
RocksDbNative.close(var1.db);
var1.db = null;
if (var1.writeOptions != null) {
RocksDbNative.writeoptionsDestroy(var1.writeOptions);
var1.writeOptions = null;
}
if (var1.readOptions != null) {
RocksDbNative.readoptionsDestroy(var1.readOptions);
var1.readOptions = null;
}
if (var1.flushOptions != null) {
RocksDbNative.flushoptionsDestroy(var1.flushOptions);
var1.flushOptions = null;
}
if (var1.blockCache != null) {
RocksDbNative.cacheDestroy(var1.blockCache);
var1.blockCache = null;
}
if (var1.blobCache != null && !var1.blobCache.equals(MemorySegment.NULL)) {
RocksDbNative.cacheDestroy(var1.blobCache);
var1.blobCache = null;
}
if (var1.options != null) {
RocksDbNative.optionsDestroy(var1.options);
var1.options = null;
}
}
class="kw">return true;
}
@Nonnull
class="kw">public IChunkLoader getLoader(@Nonnull RocksDbChunkStorageProvider.RocksDbResource var1, @Nonnull Store<ChunkStore> var2) class="kw">throws IOException {
class="kw">return new RocksDbChunkStorageProvider.Loader(var2, var1);
}
@Nonnull
class="kw">public IChunkSaver getSaver(@Nonnull RocksDbChunkStorageProvider.RocksDbResource var1, @Nonnull Store<ChunkStore> var2) class="kw">throws IOException {
class="kw">return new RocksDbChunkStorageProvider.Saver(var1);
}
class="kw">private class="kw">static byte[] toKey(int var0, int var1) {
class="kw">return new byte[]{
(byte)(var0 >>> 24), (byte)(var0 >>> 16), (byte)(var0 >>> 8), (byte)var0, (byte)(var1 >>> 24), (byte)(var1 >>> 16), (byte)(var1 >>> 8), (byte)var1
};
}
class="kw">private class="kw">static int chunkKeyX(@Nonnull MemorySegment var0) {
class="kw">return var0.get(MemorySegmentUtil.INT_BE, 0L);
}
class="kw">private class="kw">static int chunkKeyZ(@Nonnull MemorySegment var0) {
class="kw">return var0.get(MemorySegmentUtil.INT_BE, 4L);
}
@Nonnull
class="kw">private class="kw">static LongList chunkIndexesFromColumn(@Nonnull RocksDbChunkStorageProvider.RocksDbResource var0) {
LongArrayList var1 = new LongArrayList();
try (Arena var2 = Arena.ofConfined()) {
MemorySegment var3 = var2.allocate(RocksDbNative.C_SIZE_T);
MemorySegment var4 = RocksDbNative.createIteratorCf(var0.db, var0.readOptions, var0.chunkColumn);
try {
RocksDbNative.iterSeekToFirst(var4);
while (RocksDbNative.iterValid(var4)) {
MemorySegment var5 = RocksDbNative.iterKey(var4, var3);
long var6 = RocksDbNative.getSizeT(var3, 0L);
if (var6 < 8L) {
LOGGER.at(Level.WARNING).log("Skipping corrupted chunk key in chunk column: %d bytes (expected %d)", var6, 8);
RocksDbNative.iterNext(var4);
} else {
MemorySegment var8 = var5.reinterpret(var6);
var1.add(ChunkUtil.indexChunk(chunkKeyX(var8), chunkKeyZ(var8)));
RocksDbNative.iterNext(var4);
}
}
MemorySegment var16 = var2.allocate(RocksDbNative.C_POINTER);
RocksDbNative.iterGetError(var4, var16);
checkError(var16);
} class="kw">finally {
RocksDbNative.iterDestroy(var4);
}
}
class="kw">return var1;
}
class="kw">private class="kw">static void putChunkKey(@Nonnull MemorySegment var0, long var1, int var3, int var4) {
var0.set(MemorySegmentUtil.INT_BE, var1, var3);
var0.set(MemorySegmentUtil.INT_BE, var1 + 4L, var4);
}
class="kw">private class="kw">static void putSectionKey(@Nonnull MemorySegment var0, long var1, int var3, int var4, int var5) {
var0.set(MemorySegmentUtil.INT_BE, var1, var3);
var0.set(MemorySegmentUtil.INT_BE, var1 + 4L, var5);
var0.set(MemorySegmentUtil.INT_BE, var1 + 8L, var4);
}
class="kw">private class="kw">static void putBlockComponentKey(@Nonnull MemorySegment var0, long var1, int var3, int var4, int var5, short var6) {
putSectionKey(var0, var1, var3, var4, var5);
var0.set(MemorySegmentUtil.SHORT_BE, var1 + 12L, var6);
}
class="kw">private class="kw">static void putUuidKey(@Nonnull MemorySegment var0, long var1, long var3, long var5) {
var0.set(MemorySegmentUtil.LONG_BE, var1, var3);
var0.set(MemorySegmentUtil.LONG_BE, var1 + 8L, var5);
}
class="kw">private class="kw">static void multiGet(@Nonnull MemorySegment var0, @Nonnull MemorySegment var1, @Nonnull RocksDbChunkStorageProvider.Scratch var2, int var3) {
RocksDbNative.multiGetCf(var0, var1, var2.cfPtrs, var3, var2.keyPtrs, var2.keyLens, var2.valuePtrs, var2.valueLens, var2.errs);
for (int var4 = 0; var4 < var3; var4++) {
if (!var2.errs.getAtIndex(RocksDbNative.C_POINTER, var4).equals(MemorySegment.NULL)) {
String var5 = null;
for (int var6 = 0; var6 < var3; var6++) {
MemorySegment var7 = var2.errs.getAtIndex(RocksDbNative.C_POINTER, var6);
if (!var7.equals(MemorySegment.NULL)) {
if (var5 == null) {
var5 = var7.reinterpret(Long.MAX_VALUE).getString(0L);
}
RocksDbNative.free(var7);
var2.errs.setAtIndex(RocksDbNative.C_POINTER, var6, MemorySegment.NULL);
}
MemorySegment var8 = var2.valuePtrs.getAtIndex(RocksDbNative.C_POINTER, var6);
if (!var8.equals(MemorySegment.NULL)) {
RocksDbNative.free(var8);
var2.valuePtrs.setAtIndex(RocksDbNative.C_POINTER, var6, MemorySegment.NULL);
}
}
throw new RocksDbChunkStorageProvider.RocksDbException("multiGet failed: " + var5);
}
}
}
class="kw">private class="kw">static void freeValues(@Nonnull RocksDbChunkStorageProvider.Scratch var0, int var1) {
for (int var2 = 0; var2 < var1; var2++) {
MemorySegment var3 = var0.valuePtrs.getAtIndex(RocksDbNative.C_POINTER, var2);
if (!var3.equals(MemorySegment.NULL)) {
RocksDbNative.free(var3);
var0.valuePtrs.setAtIndex(RocksDbNative.C_POINTER, var2, MemorySegment.NULL);
}
}
}
class="kw">private class="kw">static long valueLen(@Nonnull RocksDbChunkStorageProvider.Scratch var0, int var1) {
class="kw">return RocksDbNative.getSizeT(var0.valueLens, var1 * RocksDbNative.C_SIZE_T.byteSize());
}
class="kw">private class="kw">static void setKeyLen(@Nonnull RocksDbChunkStorageProvider.Scratch var0, int var1, long var2) {
RocksDbNative.setSizeT(var0.keyLens, var1 * RocksDbNative.C_SIZE_T.byteSize(), var2);
}
@Nonnull
class="kw">private class="kw">static MemorySegment toNativeKey(@Nonnull Arena var0, @Nullable byte[] var1) {
if (var1 == null) {
class="kw">return MemorySegment.NULL;
}
MemorySegment var2 = var0.allocate(var1.length);
MemorySegment.copy(var1, 0, var2, ValueLayout.JAVA_BYTE, 0L, var1.length);
class="kw">return var2;
}
@Nullable
class="kw">private class="kw">static ByteBuffer valueBuffer(@Nonnull RocksDbChunkStorageProvider.Scratch var0, int var1) {
MemorySegment var2 = var0.valuePtrs.getAtIndex(RocksDbNative.C_POINTER, var1);
if (var2.equals(MemorySegment.NULL)) {
class="kw">return null;
} else {
long var3 = valueLen(var0, var1);
if (var3 > 268435456L) {
LOGGER.at(Level.WARNING).log("Skipping oversized row: %d bytes (max %d)", var3, 268435456L);
class="kw">return null;
} else {
class="kw">return var2.reinterpret(var3).asByteBuffer();
}
}
}
class="kw">private class="kw">static int stageValue(@Nonnull RocksDbChunkStorageProvider.Scratch var0, @Nullable BsonDocument var1) {
int var2 = BsonUtil.encodeInto(var1, var0.bson);
MemorySegment.copy(var0.bson.getInternalBuffer(), 0, var0.value(var2), ValueLayout.JAVA_BYTE, 0L, var2);
class="kw">return var2;
}
class="kw">public class="kw">static class Loader class="kw">implements IChunkLoader, IChunkLoader.Cubic, MetricProvider {
@Nonnull
class="kw">public class="kw">static class="kw">final MetricsRegistry<RocksDbChunkStorageProvider.Loader> METRICS_REGISTRY = new MetricsRegistry<RocksDbChunkStorageProvider.Loader>()
.register("LoadCount", var0 -> var0.loadCount.get(), Codec.LONG)
.register("LoadHitCount", var0 -> var0.loadHitCount.get(), Codec.LONG)
.register("LoadMissCount", var0 -> var0.loadMissCount.get(), Codec.LONG)
.register("LoadFailureCount", var0 -> var0.loadFailureCount.get(), Codec.LONG)
.register("TotalBytesLoaded", var0 -> var0.totalBytesLoaded.get(), Codec.LONG)
.register("ReadStats", var0 -> var0.readStats)
.register("DeserializeStats", var0 -> var0.deserializeStats);
class="kw">private class="kw">final Store<ChunkStore> store;
class="kw">private class="kw">final RocksDbChunkStorageProvider.RocksDbResource db;
class="kw">private class="kw">final AtomicLong loadCount = new AtomicLong();
class="kw">private class="kw">final AtomicLong loadHitCount = new AtomicLong();
class="kw">private class="kw">final AtomicLong loadMissCount = new AtomicLong();
class="kw">private class="kw">final AtomicLong loadFailureCount = new AtomicLong();
class="kw">private class="kw">final AtomicLong totalBytesLoaded = new AtomicLong();
class="kw">private class="kw">final BucketedOpStats readStats = new BucketedOpStats();
class="kw">private class="kw">final BucketedOpStats deserializeStats = new BucketedOpStats();
class="kw">public Loader(Store<ChunkStore> var1, RocksDbChunkStorageProvider.RocksDbResource var2) {
this.store = var1;
this.db = var2;
}
@Nonnull
@Override
class="kw">public CompletableFuture<Holder<ChunkStore>> loadHolder(int var1, int var2) {
class="kw">return this.db
.supplyIo(
SneakyThrow.sneakySupplier(
() -> {
RocksDbChunkStorageProvider.Scratch var3 = RocksDbChunkStorageProvider.SCRATCH.get();
int var4 = 21;
var3.ensureArrays(21);
int var5 = 248;
MemorySegment var6 = var3.keys(248);
int var7 = 0;
RocksDbChunkStorageProvider.putChunkKey(var6, var7, var1, var2);
var3.cfPtrs.setAtIndex(RocksDbNative.C_POINTER, 0L, this.db.chunkColumn);
var3.keyPtrs.setAtIndex(RocksDbNative.C_POINTER, 0L, var6.asSlice(var7, 8L));
RocksDbChunkStorageProvider.setKeyLen(var3, 0, 8L);
var7 += 8;
for (int var8 = 0; var8 < 10; var8++) {
int var9 = 1 + var8;
RocksDbChunkStorageProvider.putSectionKey(var6, var7, var1, var8, var2);
var3.cfPtrs.setAtIndex(RocksDbNative.C_POINTER, var9, this.db.sectionColumn);
var3.keyPtrs.setAtIndex(RocksDbNative.C_POINTER, var9, var6.asSlice(var7, 12L));
RocksDbChunkStorageProvider.setKeyLen(var3, var9, 12L);
var7 += 12;
}
for (int var32 = 0; var32 < 10; var32++) {
int var34 = 11 + var32;
RocksDbChunkStorageProvider.putSectionKey(var6, var7, var1, var32, var2);
var3.cfPtrs.setAtIndex(RocksDbNative.C_POINTER, var34, this.db.entitySectionColumn);
var3.keyPtrs.setAtIndex(RocksDbNative.C_POINTER, var34, var6.asSlice(var7, 12L));
RocksDbChunkStorageProvider.setKeyLen(var3, var34, 12L);
var7 += 12;
}
long var33 = System.nanoTime();
try {
RocksDbChunkStorageProvider.multiGet(this.db.db, this.db.readOptions, var3, 21);
} catch (RocksDbChunkStorageProvider.RocksDbException var29) {
this.loadFailureCount.getAndIncrement();
throw var29;
}
long var10 = System.nanoTime();
UUID[][] var14 = new UUID[10][];
int var15 = 0;
boolean var16 = false;
Holder var12;
Holder[] var13;
int var17;
try {
for (int var18 = 0; var18 < 21; var18++) {
if (!var3.valuePtrs.getAtIndex(RocksDbNative.C_POINTER, var18).equals(MemorySegment.NULL)) {
var15 += (int)RocksDbChunkStorageProvider.valueLen(var3, var18);
}
}
this.loadCount.getAndIncrement();
this.readStats.record(var10 - var33, var15);
ByteBuffer var36 = RocksDbChunkStorageProvider.valueBuffer(var3, 0);
if (var36 == null) {
this.loadMissCount.getAndIncrement();
class="kw">return null;
}
this.loadHitCount.getAndIncrement();
this.totalBytesLoaded.getAndAdd(var15);
BsonDocument var19 = BsonUtil.readFromBuffer(var36);
var12 = ChunkStore.REGISTRY.deserialize(var19);
if (var12 == null) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping column (%d, %d): column payload failed to deserialize", var1, var2);
class="kw">return null;
}
ChunkColumn var20 = var12.ensureAndGetComponent(ChunkColumn.getComponentType());
var16 = var20.getSectionHolders() != null
|| var12.getComponent(EntityChunk.getComponentType()) != null
|| var12.getComponent(BlockComponentChunk.getComponentType()) != null;
if (var20.getSectionHolders() != null) {
Holder[] var40 = var20.getSectionHolders();
if (var40.length < 10) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Padding truncated Sections array at chunk (%d, %d): %d sections (expected %d)", var1, var2, var40.length, 10);
var40 = Arrays.copyOf(var40, 10);
var20.putSectionHolders(var40);
}
for (int var41 = 0; var41 < var40.length; var41++) {
Holder var42 = var40[var41];
if (var42 != null) {
var42.putComponent(ChunkSection.getComponentType(), new ChunkSection(null, var1, var41, var2, false));
markEmbeddedBlockComponentsForRewrite(var42);
}
}
} else {
Holder[] var21 = new Holder[10];
for (int var22 = 0; var22 < 10; var22++) {
ByteBuffer var23 = RocksDbChunkStorageProvider.valueBuffer(var3, 1 + var22);
if (var23 != null) {
BsonDocument var24 = BsonUtil.readFromBuffer(var23);
Holder var25 = ChunkStore.REGISTRY.deserialize(var24);
if (var25 == null) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping section (%d, %d, %d): section payload failed to deserialize", var1, var22, var2);
} else {
var25.putComponent(ChunkSection.getComponentType(), new ChunkSection(null, var1, var22, var2, false));
if (markEmbeddedBlockComponentsForRewrite(var25)) {
var16 = true;
}
var21[var22] = var25;
}
}
}
var20.putSectionHolders(var21);
}
var13 = var20.getSectionHolders();
var17 = decodeEntitySectionUuids(var3, var14, var1, var2);
} class="kw">finally {
RocksDbChunkStorageProvider.freeValues(var3, 21);
}
this.loadEntitySections(var13, var14, var17, var1, var2);
if (var13 != null) {
Holder[] var37 = var13;
this.loadBlockComponentRows(var1, var2, 0, 10, var1x -> var37[var1x]);
}
WorldChunk var38 = var12.getComponent(WorldChunk.getComponentType());
assert var38 != null;
var38.loadFromHolder(this.store.getExternalData().getWorld(), var1, var2, var12);
if (var16) {
var38.setFlag(ChunkFlag.NEEDS_FORMAT_REWRITE, true);
}
long var39 = System.nanoTime();
this.deserializeStats.record(var39 - var10, var15);
class="kw">return var12;
}
)
);
}
class="kw">private class="kw">static int decodeEntitySectionUuids(@Nonnull RocksDbChunkStorageProvider.Scratch var0, @Nonnull UUID[][] var1, int var2, int var3) {
int var4 = 0;
for (int var5 = 0; var5 < 10; var5++) {
int var6 = 11 + var5;
MemorySegment var7 = var0.valuePtrs.getAtIndex(RocksDbNative.C_POINTER, var6);
if (!var7.equals(MemorySegment.NULL)) {
long var8 = RocksDbChunkStorageProvider.valueLen(var0, var6);
if (var8 % 16L != 0L) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping corrupted entity_sections row at chunk (%d, %d) section %d: %d bytes (expected multiple of 16)", var2, var3, var5, var8);
} else if (var8 / 16L > 65536L) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log(
"Skipping corrupted entity_sections row at chunk (%d, %d) section %d: %d entities exceeds the %d cap",
var2,
var3,
var5,
var8 / 16L,
65536L
);
} else {
int var10 = (int)(var8 / 16L);
UUID[] var11 = new UUID[var10];
MemorySegment var12 = var7.reinterpret(var8);
for (int var13 = 0; var13 < var10; var13++) {
long var14 = var12.get(MemorySegmentUtil.LONG_BE, var13 * 16L);
long var16 = var12.get(MemorySegmentUtil.LONG_BE, var13 * 16L + 8L);
var11[var13] = new UUID(var14, var16);
}
var1[var5] = var11;
var4 += var10;
}
}
}
class="kw">return var4;
}
class="kw">private void loadEntitySections(@Nullable Holder<ChunkStore>[] var1, @Nonnull UUID[][] var2, int var3, int var4, int var5) {
if (var1 != null) {
RocksDbChunkStorageProvider.Scratch var6 = RocksDbChunkStorageProvider.SCRATCH.get();
if (var3 > 0) {
var6.ensureArrays(var3);
MemorySegment var7 = var6.keys(var3 * 16);
int var8 = 0;
for (int var9 = 0; var9 < 10; var9++) {
UUID[] var10 = var2[var9];
if (var10 != null) {
for (UUID var14 : var10) {
long var15 = var8 * 16L;
RocksDbChunkStorageProvider.putUuidKey(var7, var15, var14.getMostSignificantBits(), var14.getLeastSignificantBits());
var6.cfPtrs.setAtIndex(RocksDbNative.C_POINTER, var8, this.db.entityColumn);
var6.keyPtrs.setAtIndex(RocksDbNative.C_POINTER, var8, var7.asSlice(var15, 16L));
RocksDbChunkStorageProvider.setKeyLen(var6, var8, 16L);
var8++;
}
}
}
RocksDbChunkStorageProvider.multiGet(this.db.db, this.db.readOptions, var6, var3);
}
try {
int var22 = 0;
for (int var23 = 0; var23 < 10; var23++) {
UUID[] var24 = var2[var23];
if (var24 != null) {
Holder var25 = var1[var23];
if (var25 == null) {
var22 += var24.length;
} else {
ObjectArrayList var26 = new ObjectArrayList(var24.length);
for (int var27 = 0; var27 < var24.length; var27++) {
ByteBuffer var28 = RocksDbChunkStorageProvider.valueBuffer(var6, var22 + var27);
if (var28 != null) {
try {
BsonDocument var29 = BsonUtil.readFromBuffer(var28);
if (var29 == null) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping corrupted entity %s at chunk (%d, %d) section %d: empty body row", var24[var27], var4, var5, var23);
} else {
Holder var30 = EntityStore.REGISTRY.deserialize(var29);
if (var30 != null) {
TransformComponent var16 = var30.getComponent(TransformComponent.getComponentType());
if (var16 != null) {
var16.seedLastSavedPosition();
}
var26.add(var30);
}
}
} catch (Exception var20) {
((HytaleLogger.Api)RocksDbChunkStorageProvider.LOGGER.at(Level.WARNING).withCause(var20))
.log("Skipping corrupted entity %s at chunk (%d, %d) section %d: body failed to decode", var24[var27], var4, var5, var23);
}
}
}
var22 += var24.length;
var25.putComponent(EntitySection.getComponentType(), new EntitySection(var26, new ReferenceOpenHashSet()));
}
}
}
} class="kw">finally {
if (var3 > 0) {
RocksDbChunkStorageProvider.freeValues(var6, var3);
}
}
}
}
@Nonnull
@Override
class="kw">public LongList getIndexes() class="kw">throws IOException {
class="kw">return RocksDbChunkStorageProvider.chunkIndexesFromColumn(this.db);
}
@Override
class="kw">public void close() class="kw">throws IOException {
}
@Nonnull
@Override
class="kw">public MetricResults toMetricResults() {
class="kw">return METRICS_REGISTRY.toMetricResults(this);
}
@Override
class="kw">public CompletableFuture<Holder<ChunkStore>> loadSectionHolder(int var1, int var2, int var3) {
class="kw">return this.db
.supplyIo(
SneakyThrow.sneakySupplier(
() -> {
RocksDbChunkStorageProvider.Scratch var4 = RocksDbChunkStorageProvider.SCRATCH.get();
var4.ensureArrays(2);
MemorySegment var5 = var4.keys(24);
RocksDbChunkStorageProvider.putSectionKey(var5, 0L, var1, var2, var3);
var4.cfPtrs.setAtIndex(RocksDbNative.C_POINTER, 0L, this.db.sectionColumn);
var4.keyPtrs.setAtIndex(RocksDbNative.C_POINTER, 0L, var5.asSlice(0L, 12L));
RocksDbChunkStorageProvider.setKeyLen(var4, 0, 12L);
RocksDbChunkStorageProvider.putSectionKey(var5, 12L, var1, var2, var3);
var4.cfPtrs.setAtIndex(RocksDbNative.C_POINTER, 1L, this.db.entitySectionColumn);
var4.keyPtrs.setAtIndex(RocksDbNative.C_POINTER, 1L, var5.asSlice(12L, 12L));
RocksDbChunkStorageProvider.setKeyLen(var4, 1, 12L);
long var6 = 0L;
long var8 = 0L;
long var10 = System.nanoTime();
try {
RocksDbChunkStorageProvider.multiGet(this.db.db, this.db.readOptions, var4, 2);
} catch (RocksDbChunkStorageProvider.RocksDbException var37) {
this.loadFailureCount.getAndIncrement();
throw var37;
}
var6 += System.nanoTime() - var10;
UUID[] var13 = null;
Holder var12;
int var14;
try {
boolean var15 = !var4.valuePtrs.getAtIndex(RocksDbNative.C_POINTER, 0L).equals(MemorySegment.NULL);
boolean var16 = !var4.valuePtrs.getAtIndex(RocksDbNative.C_POINTER, 1L).equals(MemorySegment.NULL);
long var17 = var16 ? RocksDbChunkStorageProvider.valueLen(var4, 1) : 0L;
this.loadCount.getAndIncrement();
if (!var15) {
this.loadMissCount.getAndIncrement();
this.readStats.record(var6, (int)var17);
class="kw">return null;
}
this.loadHitCount.getAndIncrement();
var14 = (int)(RocksDbChunkStorageProvider.valueLen(var4, 0) + var17);
if (var16) {
if (var17 % 16L != 0L) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log(
"Skipping corrupted entity_sections row at section (%d, %d, %d): %d bytes (expected multiple of 16)",
var1,
var2,
var3,
var17
);
} else if (var17 / 16L > 65536L) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log(
"Skipping corrupted entity_sections row at section (%d, %d, %d): %d entities exceeds the %d cap",
var1,
var2,
var3,
var17 / 16L,
65536L
);
} else {
int var19 = (int)(var17 / 16L);
var13 = new UUID[var19];
MemorySegment var20 = var4.valuePtrs.getAtIndex(RocksDbNative.C_POINTER, 1L).reinterpret(var17);
for (int var21 = 0; var21 < var19; var21++) {
long var22 = var20.get(MemorySegmentUtil.LONG_BE, var21 * 16L);
long var24 = var20.get(MemorySegmentUtil.LONG_BE, var21 * 16L + 8L);
var13[var21] = new UUID(var22, var24);
}
}
}
long var48 = System.nanoTime();
BsonDocument var50 = BsonUtil.readFromBuffer(RocksDbChunkStorageProvider.valueBuffer(var4, 0));
var12 = ChunkStore.REGISTRY.deserialize(var50);
if (var12 == null) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping section (%d, %d, %d): section payload failed to deserialize", var1, var2, var3);
class="kw">return null;
}
var12.putComponent(ChunkSection.getComponentType(), new ChunkSection(null, var1, var2, var3, false));
var8 += System.nanoTime() - var48;
} class="kw">finally {
RocksDbChunkStorageProvider.freeValues(var4, 2);
}
this.totalBytesLoaded.getAndAdd(var14);
if (var13 != null) {
ObjectArrayList var43 = new ObjectArrayList(var13.length);
if (var13.length > 0) {
var4.ensureArrays(var13.length);
MemorySegment var45 = var4.keys(var13.length * 16);
for (int var46 = 0; var46 < var13.length; var46++) {
long var18 = var46 * 16L;
RocksDbChunkStorageProvider.putUuidKey(
var45, var18, var13[var46].getMostSignificantBits(), var13[var46].getLeastSignificantBits()
);
var4.cfPtrs.setAtIndex(RocksDbNative.C_POINTER, var46, this.db.entityColumn);
var4.keyPtrs.setAtIndex(RocksDbNative.C_POINTER, var46, var45.asSlice(var18, 16L));
RocksDbChunkStorageProvider.setKeyLen(var4, var46, 16L);
}
var10 = System.nanoTime();
RocksDbChunkStorageProvider.multiGet(this.db.db, this.db.readOptions, var4, var13.length);
var6 += System.nanoTime() - var10;
try {
long var47 = System.nanoTime();
long var49 = 0L;
for (int var51 = 0; var51 < var13.length; var51++) {
ByteBuffer var52 = RocksDbChunkStorageProvider.valueBuffer(var4, var51);
if (var52 != null) {
var49 += RocksDbChunkStorageProvider.valueLen(var4, var51);
try {
BsonDocument var23 = BsonUtil.readFromBuffer(var52);
if (var23 == null) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping corrupted entity %s at section (%d, %d, %d): empty body row", var13[var51], var1, var2, var3);
} else {
Holder var53 = EntityStore.REGISTRY.deserialize(var23);
if (var53 != null) {
TransformComponent var25 = var53.getComponent(TransformComponent.getComponentType());
if (var25 != null) {
var25.seedLastSavedPosition();
}
var43.add(var53);
}
}
} catch (Exception var36) {
((HytaleLogger.Api)RocksDbChunkStorageProvider.LOGGER.at(Level.WARNING).withCause(var36))
.log("Skipping corrupted entity %s at section (%d, %d, %d): body failed to decode", var13[var51], var1, var2, var3);
}
}
}
var8 += System.nanoTime() - var47;
var14 += (int)var49;
this.totalBytesLoaded.getAndAdd(var49);
} class="kw">finally {
RocksDbChunkStorageProvider.freeValues(var4, var13.length);
}
}
var12.putComponent(EntitySection.getComponentType(), new EntitySection(var43, new ReferenceOpenHashSet()));
}
if (markEmbeddedBlockComponentsForRewrite(var12)) {
ChunkSection var44 = var12.getComponent(ChunkSection.getComponentType());
assert var44 != null;
var44.markNeedsSaving();
}
this.loadBlockComponentRows(var1, var3, var2, var2 + 1, var1x -> var12);
this.readStats.record(var6, var14);
this.deserializeStats.record(var8, var14);
class="kw">return var12;
}
)
);
}
class="kw">private class="kw">static boolean markEmbeddedBlockComponentsForRewrite(@Nonnull Holder<ChunkStore> var0) {
BlockComponentSection var1 = var0.getComponent(BlockComponentSection.getComponentType());
if (var1 != null && !var1.getBlockHolders().isEmpty()) {
var1.markAllBlocksNeedsSaving();
class="kw">return true;
} else {
class="kw">return false;
}
}
class="kw">private void loadBlockComponentRows(int var1, int var2, int var3, int var4, @Nonnull IntFunction<Holder<ChunkStore>> var5) {
try (Arena var6 = Arena.ofConfined()) {
MemorySegment var7 = var6.allocate(12L);
MemorySegment var8 = var6.allocate(RocksDbNative.C_SIZE_T);
MemorySegment var9 = var6.allocate(RocksDbNative.C_POINTER);
MemorySegment var10 = RocksDbNative.createIteratorCf(this.db.db, this.db.readOptions, this.db.blockComponentColumn);
try {
long var11 = 0L;
for (int var13 = var3; var13 < var4; var13++) {
BlockComponentSection var14 = null;
BlockSection var15 = null;
boolean var16 = false;
RocksDbChunkStorageProvider.putSectionKey(var7, 0L, var1, var13, var2);
RocksDbNative.iterSeek(var10, var7, 12L);
while (RocksDbNative.iterValid(var10)) {
MemorySegment var17 = RocksDbNative.iterKey(var10, var8);
long var18 = RocksDbNative.getSizeT(var8, 0L);
if (var18 < 12L) {
break;
}
MemorySegment var20 = var17.reinterpret(var18);
if (var20.get(MemorySegmentUtil.INT_BE, 0L) != var1
|| var20.get(MemorySegmentUtil.INT_BE, 4L) != var2
|| var20.get(MemorySegmentUtil.INT_BE, 8L) != var13) {
break;
}
if (var18 != 14L) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping corrupted block_components key at section (%d, %d, %d): %d bytes (expected %d)", var1, var13, var2, var18, 14);
RocksDbNative.iterNext(var10);
} else {
int var21 = Short.toUnsignedInt(var20.get(MemorySegmentUtil.SHORT_BE, 12L));
if (var21 >= 32768) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping block component row at section (%d, %d, %d): index %d out of range (max %d)", var1, var13, var2, var21, 32767);
RocksDbNative.iterNext(var10);
} else {
if (!var16) {
var16 = true;
Holder var22 = var5.apply(var13);
if (var22 != null) {
var14 = var22.ensureAndGetComponent(BlockComponentSection.getComponentType());
var15 = var22.getComponent(BlockSection.getComponentType());
}
}
if (var14 == null) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping block component row at section (%d, %d, %d) index %d: no section payload", var1, var13, var2, var21);
RocksDbNative.iterNext(var10);
} else {
MemorySegment var36 = RocksDbNative.iterValue(var10, var8);
long var23 = RocksDbNative.getSizeT(var8, 0L);
if (var23 > 268435456L) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log(
"Skipping oversized block component row at section (%d, %d, %d) index %d: %d bytes (max %d)",
var1,
var13,
var2,
var21,
var23,
268435456L
);
RocksDbNative.iterNext(var10);
} else {
var11 += var23;
Holder var25 = null;
try {
BsonDocument var26 = BsonUtil.readFromBuffer(var36.reinterpret(var23).asByteBuffer());
if (var26 != null) {
var25 = ChunkStore.REGISTRY.deserialize(var26);
}
} catch (Exception var33) {
((HytaleLogger.Api)RocksDbChunkStorageProvider.LOGGER.at(Level.WARNING).withCause(var33))
.log("Skipping corrupted block component row at section (%d, %d, %d) index %d", var1, var13, var2, var21);
}
if (var25 == null) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log(
"Skipping block component row at section (%d, %d, %d) index %d: payload failed to deserialize",
var1,
var13,
var2,
var21
);
RocksDbNative.iterNext(var10);
} else {
if (var15 != null && var15.get(ChunkUtil.xFromIndex(var21), ChunkUtil.yFromIndex(var21), ChunkUtil.zFromIndex(var21)) == 0) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Dropping orphaned block component row at section (%d, %d, %d) index %d: block is air", var1, var13, var2, var21);
var14.removeBlockHolder((short)var21);
var14.tombstoneBlock((short)var21);
} else {
var14.loadBlockHolder((short)var21, var25);
}
RocksDbNative.iterNext(var10);
}
}
}
}
}
}
RocksDbNative.iterGetError(var10, var9);
RocksDbChunkStorageProvider.checkError(var9);
}
this.totalBytesLoaded.getAndAdd(var11);
} class="kw">finally {
RocksDbNative.iterDestroy(var10);
}
}
}
}
class="kw">public class="kw">static class RocksDbException class="kw">extends RuntimeException {
class="kw">public RocksDbException(@Nonnull String var1) {
super(var1);
}
}
class="kw">public class="kw">static class RocksDbResource {
class="kw">public MemorySegment db;
class="kw">public MemorySegment chunkColumn;
class="kw">public MemorySegment sectionColumn;
class="kw">public MemorySegment entitySectionColumn;
class="kw">public MemorySegment entityColumn;
class="kw">public MemorySegment blockComponentColumn;
class="kw">public MemorySegment options;
@Nullable
class="kw">public MemorySegment blockCache;
@Nullable
class="kw">public MemorySegment blobCache;
class="kw">public MemorySegment writeOptions;
class="kw">public MemorySegment readOptions;
class="kw">public MemorySegment flushOptions;
class="kw">public boolean statisticsEnabled;
class="kw">public ExecutorService ioExecutor;
class="kw">private class="kw">final Set<CompletableFuture<?>> inFlightIo = ConcurrentHashMap.newKeySet();
class="kw">public RocksDbResource() {
}
@Nonnull
class="kw">public <T> CompletableFuture<T> supplyIo(@Nonnull Supplier<T> var1) {
CompletableFuture var2 = new CompletableFuture<>();
this.inFlightIo.add(var2);
var2.whenComplete((var2x, var3) -> this.inFlightIo.remove(var2));
try {
this.ioExecutor.execute(() -> {
try {
var2.complete(var1.get());
} catch (Throwable var3) {
var2.completeExceptionally(var3);
}
});
} catch (RejectedExecutionException var4) {
var2.completeExceptionally(var4);
}
class="kw">return var2;
}
@Nonnull
class="kw">public CompletableFuture<Void> runIo(@Nonnull Runnable var1) {
class="kw">return this.supplyIo(() -> {
var1.run();
class="kw">return null;
});
}
}
class="kw">public class="kw">static class RocksDbStatistics class="kw">implements MetricProvider {
@Nonnull
class="kw">public class="kw">static class="kw">final MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStatistics> METRICS_REGISTRY = buildRegistry();
@Nonnull
class="kw">public class="kw">final long[] tickers;
@Nonnull
class="kw">public class="kw">final RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot[] histograms;
class="kw">private RocksDbStatistics(@Nonnull long[] var1, @Nonnull RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot[] var2) {
this.tickers = var1;
this.histograms = var2;
}
@Nonnull
class="kw">public class="kw">static RocksDbChunkStorageProvider.RocksDbStatistics snapshot(@Nonnull MemorySegment var0) {
long[] var1 = new long[RocksDbNative.STATISTICS_TICKERS.length];
for (int var2 = 0; var2 < RocksDbNative.STATISTICS_TICKERS.length; var2++) {
var1[var2] = RocksDbNative.optionsStatisticsGetTickerCount(var0, RocksDbNative.STATISTICS_TICKERS[var2].type());
}
RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot[] var8 = new RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot[RocksDbNative.STATISTICS_HISTOGRAMS.length];
MemorySegment var3 = RocksDbNative.statisticsHistogramDataCreate();
try {
for (int var4 = 0; var4 < RocksDbNative.STATISTICS_HISTOGRAMS.length; var4++) {
RocksDbNative.optionsStatisticsGetHistogramData(var0, RocksDbNative.STATISTICS_HISTOGRAMS[var4].type(), var3);
var8[var4] = RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot.from(var3);
}
} class="kw">finally {
RocksDbNative.statisticsHistogramDataDestroy(var3);
}
class="kw">return new RocksDbChunkStorageProvider.RocksDbStatistics(var1, var8);
}
@Nonnull
@Override
class="kw">public MetricResults toMetricResults() {
class="kw">return METRICS_REGISTRY.toMetricResults(this);
}
@Nonnull
class="kw">private class="kw">static MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStatistics> buildRegistry() {
MetricsRegistry var0 = new MetricsRegistry<>();
for (int var1 = 0; var1 < RocksDbNative.STATISTICS_TICKERS.length; var1++) {
int var2 = var1;
var0 = var0.register(RocksDbNative.STATISTICS_TICKERS[var1].name(), var1x -> var1x.tickers[var2], Codec.LONG);
}
for (int var3 = 0; var3 < RocksDbNative.STATISTICS_HISTOGRAMS.length; var3++) {
int var4 = var3;
var0 = var0.register(RocksDbNative.STATISTICS_HISTOGRAMS[var3].name(), var1x -> var1x.histograms[var4]);
}
class="kw">return var0;
}
class="kw">public record HistogramSnapshot(long count, long sum, double average, double median, double p95, double p99, double max, double stdDev)
class="kw">implements MetricProvider {
@Nonnull
class="kw">public class="kw">static class="kw">final MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot> METRICS_REGISTRY = new MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot>()
.register("Count", RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot::count, Codec.LONG)
.register("Sum", RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot::sum, Codec.LONG)
.register("Average", RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot::average, Codec.DOUBLE)
.register("Median", RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot::median, Codec.DOUBLE)
.register("P95", RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot::p95, Codec.DOUBLE)
.register("P99", RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot::p99, Codec.DOUBLE)
.register("Max", RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot::max, Codec.DOUBLE)
.register("StdDev", RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot::stdDev, Codec.DOUBLE);
class="kw">public HistogramSnapshot {
}
@Nonnull
class="kw">public class="kw">static RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot from(@Nonnull MemorySegment var0) {
class="kw">return new RocksDbChunkStorageProvider.RocksDbStatistics.HistogramSnapshot(
RocksDbNative.statisticsHistogramDataGetCount(var0),
RocksDbNative.statisticsHistogramDataGetSum(var0),
RocksDbNative.statisticsHistogramDataGetAverage(var0),
RocksDbNative.statisticsHistogramDataGetMedian(var0),
RocksDbNative.statisticsHistogramDataGetP95(var0),
RocksDbNative.statisticsHistogramDataGetP99(var0),
RocksDbNative.statisticsHistogramDataGetMax(var0),
RocksDbNative.statisticsHistogramDataGetStdDev(var0)
);
}
@Nonnull
@Override
class="kw">public MetricResults toMetricResults() {
class="kw">return METRICS_REGISTRY.toMetricResults(this);
}
}
}
class="kw">public record RocksDbStats(
long blockCacheBytes,
long blockCachePinnedBytes,
long blockCacheCapacityBytes,
long blobCacheBytes,
long blobCachePinnedBytes,
long blobCacheCapacityBytes,
long backgroundErrors,
long memTableFlushPending,
long numRunningFlushes,
long numSnapshots,
long numLiveVersions,
long isWriteStopped,
long actualDelayedWriteRate,
@Nonnull RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats chunks,
@Nonnull RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats sections,
@Nonnull RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats entitySections,
@Nonnull RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats entities
) class="kw">implements MetricProvider {
class="kw">public class="kw">static class="kw">final int LEVEL_COUNT = 7;
@Nonnull
class="kw">public class="kw">static class="kw">final MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStats> METRICS_REGISTRY = new MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStats>()
.register("BlockCacheBytes", RocksDbChunkStorageProvider.RocksDbStats::blockCacheBytes, Codec.LONG)
.register("BlockCachePinnedBytes", RocksDbChunkStorageProvider.RocksDbStats::blockCachePinnedBytes, Codec.LONG)
.register("BlockCacheCapacityBytes", RocksDbChunkStorageProvider.RocksDbStats::blockCacheCapacityBytes, Codec.LONG)
.register("BlobCacheBytes", RocksDbChunkStorageProvider.RocksDbStats::blobCacheBytes, Codec.LONG)
.register("BlobCachePinnedBytes", RocksDbChunkStorageProvider.RocksDbStats::blobCachePinnedBytes, Codec.LONG)
.register("BlobCacheCapacityBytes", RocksDbChunkStorageProvider.RocksDbStats::blobCacheCapacityBytes, Codec.LONG)
.register("BackgroundErrors", RocksDbChunkStorageProvider.RocksDbStats::backgroundErrors, Codec.LONG)
.register("MemTableFlushPending", RocksDbChunkStorageProvider.RocksDbStats::memTableFlushPending, Codec.LONG)
.register("NumRunningFlushes", RocksDbChunkStorageProvider.RocksDbStats::numRunningFlushes, Codec.LONG)
.register("NumSnapshots", RocksDbChunkStorageProvider.RocksDbStats::numSnapshots, Codec.LONG)
.register("NumLiveVersions", RocksDbChunkStorageProvider.RocksDbStats::numLiveVersions, Codec.LONG)
.register("IsWriteStopped", RocksDbChunkStorageProvider.RocksDbStats::isWriteStopped, Codec.LONG)
.register("ActualDelayedWriteRate", RocksDbChunkStorageProvider.RocksDbStats::actualDelayedWriteRate, Codec.LONG)
.register("Chunks", RocksDbChunkStorageProvider.RocksDbStats::chunks)
.register("Sections", RocksDbChunkStorageProvider.RocksDbStats::sections)
.register("EntitySections", RocksDbChunkStorageProvider.RocksDbStats::entitySections)
.register("Entities", RocksDbChunkStorageProvider.RocksDbStats::entities);
class="kw">public RocksDbStats {
}
@Nonnull
class="kw">public class="kw">static RocksDbChunkStorageProvider.RocksDbStats snapshot(@Nonnull RocksDbChunkStorageProvider.RocksDbResource var0) {
MemorySegment var1 = var0.db;
try (Arena var2 = Arena.ofConfined()) {
class="kw">return new RocksDbChunkStorageProvider.RocksDbStats(
getLongDb(var2, var1, "rocksdb.block-cache-usage"),
getLongDb(var2, var1, "rocksdb.block-cache-pinned-usage"),
getLongDb(var2, var1, "rocksdb.block-cache-capacity"),
RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats.getLongCf(var2, var1, var0.chunkColumn, "rocksdb.blob-cache-usage"),
RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats.getLongCf(var2, var1, var0.chunkColumn, "rocksdb.blob-cache-pinned-usage"),
RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats.getLongCf(var2, var1, var0.chunkColumn, "rocksdb.blob-cache-capacity"),
getLongDb(var2, var1, "rocksdb.background-errors"),
getLongDb(var2, var1, "rocksdb.mem-table-flush-pending"),
getLongDb(var2, var1, "rocksdb.num-running-flushes"),
getLongDb(var2, var1, "rocksdb.num-snapshots"),
getLongDb(var2, var1, "rocksdb.num-live-versions"),
getLongDb(var2, var1, "rocksdb.is-write-stopped"),
getLongDb(var2, var1, "rocksdb.actual-delayed-write-rate"),
RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats.snapshot(var2, var1, var0.chunkColumn),
RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats.snapshot(var2, var1, var0.sectionColumn),
RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats.snapshot(var2, var1, var0.entitySectionColumn),
RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats.snapshot(var2, var1, var0.entityColumn)
);
}
}
@Nonnull
@Override
class="kw">public MetricResults toMetricResults() {
class="kw">return METRICS_REGISTRY.toMetricResults(this);
}
class="kw">private class="kw">static long getLongDb(@Nonnull Arena var0, @Nonnull MemorySegment var1, @Nonnull String var2) {
MemorySegment var3 = var0.allocateFrom(var2);
MemorySegment var4 = var0.allocate(ValueLayout.JAVA_LONG);
class="kw">return RocksDbNative.propertyInt(var1, var3, var4) == 0 ? var4.get(ValueLayout.JAVA_LONG, 0L) : -1L;
}
class="kw">public record ColumnFamilyStats(
long estimateNumKeys,
long estimateLiveDataBytes,
long totalSstFilesBytes,
long liveSstFilesBytes,
long numBlobFiles,
long totalBlobFilesBytes,
long liveBlobFilesBytes,
long memTableBytes,
long allMemTableBytes,
long numImmutableMemTable,
long compactionPending,
long numRunningCompactions,
long pendingCompactionBytes,
@Nonnull long[] filesPerLevel
) class="kw">implements MetricProvider {
@Nonnull
class="kw">public class="kw">static class="kw">final MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats> METRICS_REGISTRY = new MetricsRegistry<RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats>()
.register("EstimateNumKeys", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::estimateNumKeys, Codec.LONG)
.register("EstimateLiveDataBytes", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::estimateLiveDataBytes, Codec.LONG)
.register("TotalSstFilesBytes", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::totalSstFilesBytes, Codec.LONG)
.register("LiveSstFilesBytes", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::liveSstFilesBytes, Codec.LONG)
.register("NumBlobFiles", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::numBlobFiles, Codec.LONG)
.register("TotalBlobFilesBytes", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::totalBlobFilesBytes, Codec.LONG)
.register("LiveBlobFilesBytes", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::liveBlobFilesBytes, Codec.LONG)
.register("MemTableBytes", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::memTableBytes, Codec.LONG)
.register("AllMemTableBytes", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::allMemTableBytes, Codec.LONG)
.register("NumImmutableMemTable", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::numImmutableMemTable, Codec.LONG)
.register("CompactionPending", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::compactionPending, Codec.LONG)
.register("NumRunningCompactions", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::numRunningCompactions, Codec.LONG)
.register("PendingCompactionBytes", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::pendingCompactionBytes, Codec.LONG)
.register("FilesPerLevel", RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats::filesPerLevel, Codec.LONG_ARRAY);
class="kw">public ColumnFamilyStats {
}
@Nonnull
class="kw">public class="kw">static RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats snapshot(
@Nonnull Arena var0, @Nonnull MemorySegment var1, @Nonnull MemorySegment var2
) {
long[] var3 = new long[7];
for (int var4 = 0; var4 < var3.length; var4++) {
var3[var4] = getStringLongCf(var0, var1, var2, "rocksdb.num-files-at-level" + var4);
}
class="kw">return new RocksDbChunkStorageProvider.RocksDbStats.ColumnFamilyStats(
getLongCf(var0, var1, var2, "rocksdb.estimate-num-keys"),
getLongCf(var0, var1, var2, "rocksdb.estimate-live-data-size"),
getLongCf(var0, var1, var2, "rocksdb.total-sst-files-size"),
getLongCf(var0, var1, var2, "rocksdb.live-sst-files-size"),
getLongCf(var0, var1, var2, "rocksdb.num-blob-files"),
getLongCf(var0, var1, var2, "rocksdb.total-blob-file-size"),
getLongCf(var0, var1, var2, "rocksdb.live-blob-file-size"),
getLongCf(var0, var1, var2, "rocksdb.cur-size-all-mem-tables"),
getLongCf(var0, var1, var2, "rocksdb.size-all-mem-tables"),
getLongCf(var0, var1, var2, "rocksdb.num-immutable-mem-table"),
getLongCf(var0, var1, var2, "rocksdb.compaction-pending"),
getLongCf(var0, var1, var2, "rocksdb.num-running-compactions"),
getLongCf(var0, var1, var2, "rocksdb.estimate-pending-compaction-bytes"),
var3
);
}
@Nonnull
@Override
class="kw">public MetricResults toMetricResults() {
class="kw">return METRICS_REGISTRY.toMetricResults(this);
}
class="kw">private class="kw">static long getLongCf(@Nonnull Arena var0, @Nonnull MemorySegment var1, @Nonnull MemorySegment var2, @Nonnull String var3) {
MemorySegment var4 = var0.allocateFrom(var3);
MemorySegment var5 = var0.allocate(ValueLayout.JAVA_LONG);
class="kw">return RocksDbNative.propertyIntCf(var1, var2, var4, var5) == 0 ? var5.get(ValueLayout.JAVA_LONG, 0L) : -1L;
}
class="kw">private class="kw">static long getStringLongCf(@Nonnull Arena var0, @Nonnull MemorySegment var1, @Nonnull MemorySegment var2, @Nonnull String var3) {
MemorySegment var4 = var0.allocateFrom(var3);
MemorySegment var5 = RocksDbNative.propertyValueCf(var1, var2, var4);
if (var5.equals(MemorySegment.NULL)) {
class="kw">return -1L;
}
try {
class="kw">return Long.parseLong(var5.reinterpret(Long.MAX_VALUE).getString(0L).trim());
} catch (NumberFormatException var12) {
class="kw">return -1L;
} class="kw">finally {
RocksDbNative.free(var5);
}
}
}
}
class="kw">public class="kw">static class Saver class="kw">implements IChunkSaver, IChunkSaver.Cubic, MetricProvider {
@Nonnull
class="kw">public class="kw">static class="kw">final MetricsRegistry<RocksDbChunkStorageProvider.Saver> METRICS_REGISTRY = new MetricsRegistry<RocksDbChunkStorageProvider.Saver>()
.register("SaveCount", var0 -> var0.saveCount.get(), Codec.LONG)
.register("SaveFailureCount", var0 -> var0.saveFailureCount.get(), Codec.LONG)
.register("RemoveCount", var0 -> var0.removeCount.get(), Codec.LONG)
.register("RemoveFailureCount", var0 -> var0.removeFailureCount.get(), Codec.LONG)
.register("TotalBytesSaved", var0 -> var0.totalBytesSaved.get(), Codec.LONG)
.register("FlushCount", var0 -> var0.flushCount.get(), Codec.LONG)
.register("CompactCount", var0 -> var0.compactCount.get(), Codec.LONG)
.register("SerializeStats", var0 -> var0.serializeStats)
.register("WriteStats", var0 -> var0.writeStats)
.register("RemoveStats", var0 -> var0.removeStats)
.register("DbStats", var0 -> RocksDbChunkStorageProvider.RocksDbStats.snapshot(var0.db))
.register("DbStatistics", var0 -> var0.db.statisticsEnabled ? RocksDbChunkStorageProvider.RocksDbStatistics.snapshot(var0.db.options) : null);
class="kw">private class="kw">final RocksDbChunkStorageProvider.RocksDbResource db;
class="kw">private class="kw">final AtomicLong saveCount = new AtomicLong();
class="kw">private class="kw">final AtomicLong saveFailureCount = new AtomicLong();
class="kw">private class="kw">final AtomicLong removeCount = new AtomicLong();
class="kw">private class="kw">final AtomicLong removeFailureCount = new AtomicLong();
class="kw">private class="kw">final AtomicLong totalBytesSaved = new AtomicLong();
class="kw">private class="kw">final AtomicLong flushCount = new AtomicLong();
class="kw">private class="kw">final AtomicLong compactCount = new AtomicLong();
class="kw">private class="kw">final BucketedOpStats serializeStats = new BucketedOpStats();
class="kw">private class="kw">final BucketedOpStats writeStats = new BucketedOpStats();
class="kw">private class="kw">final BucketedOpStats removeStats = new BucketedOpStats();
class="kw">public Saver(RocksDbChunkStorageProvider.RocksDbResource var1) {
this.db = var1;
}
@Override
class="kw">public CompletableFuture<Void> saveSection(
int var1, int var2, int var3, @Nonnull Store<ChunkStore> var4, @Nonnull Ref<ChunkStore> var5, @Nullable Executor var6, @Nullable Runnable var7
) {
Holder var8 = var4.copySerializableEntity(
var5,
ChunkStore.REGISTRY.newHolder(),
var0 -> !var0.equals(EntitySection.getComponentType()) && !var0.equals(BlockComponentSection.getComponentType())
);
CompletableFuture var9 = this.db.runIo(SneakyThrow.sneakyRunnable(() -> {
RocksDbChunkStorageProvider.Scratch var5 = RocksDbChunkStorageProvider.SCRATCH.get();
long var6 = System.nanoTime();
try {
MemorySegment var8 = var5.keys(12);
RocksDbChunkStorageProvider.putSectionKey(var8, 0L, var1, var2, var3);
BsonDocument var9 = ChunkStore.REGISTRY.serialize(var8);
int var10 = RocksDbChunkStorageProvider.stageValue(var5, var9);
long var11 = System.nanoTime();
RocksDbNative.putCf(this.db.db, this.db.writeOptions, this.db.sectionColumn, var8, 12L, var5.value, var10, var5.clearErrPtr());
RocksDbChunkStorageProvider.checkError(var5.errPtr);
long var13 = System.nanoTime();
this.saveCount.getAndIncrement();
this.totalBytesSaved.getAndAdd(var10);
this.serializeStats.record(var11 - var6, var10);
this.writeStats.record(var13 - var11, var10);
} catch (RocksDbChunkStorageProvider.RocksDbException var15) {
this.saveFailureCount.getAndIncrement();
throw var15;
}
}));
if (var7 != null) {
var9.whenComplete((var1x, var2x) -> var7.run());
}
class="kw">return var9;
}
@Override
class="kw">public CompletableFuture<Void> saveEntitySection(
int var1, int var2, int var3, @Nonnull Store<ChunkStore> var4, @Nonnull EntitySection var5, @Nullable Executor var6, @Nullable Runnable var7
) {
ComponentRegistry.Data var8 = EntityStore.REGISTRY.getData();
List var9 = var5.getEntityHolders();
Set var10 = var5.getEntityReferences();
ObjectArrayList var11 = new ObjectArrayList(var9.size() + var10.size());
collectEntityUuidsFromHolders(var9, var8, var11);
collectEntityUuidsFromReferences(var10, var8, var11);
ObjectArrayList var12 = new ObjectArrayList(var9.size() + var10.size());
ReferenceArrayList var13 = new ReferenceArrayList();
boolean var15 = false;
CompletableFuture var14;
try {
snapshotDirtyEntityHolders(var9, var8, var12, var13);
snapshotDirtyEntityReferences(var10, var8, var12, var13);
var14 = this.db
.runIo(
SneakyThrow.sneakyRunnable(
() -> {
RocksDbChunkStorageProvider.Scratch var6 = RocksDbChunkStorageProvider.SCRATCH.get();
MemorySegment var7 = var6.writeBatch();
long var8 = System.nanoTime();
try {
int var10 = var11.size();
int var11 = 16 * var10;
MemorySegment var12 = var6.keys(12);
RocksDbChunkStorageProvider.putSectionKey(var12, 0L, var1, var2, var3);
MemorySegment var13 = var6.value(var11);
for (int var14 = 0; var14 < var10; var14++) {
UUID var15 = (UUID)var11.get(var14);
RocksDbChunkStorageProvider.putUuidKey(var13, var14 * 16L, var15.getMostSignificantBits(), var15.getLeastSignificantBits());
}
RocksDbNative.writebatchPutCf(var7, this.db.entitySectionColumn, var12, 12L, var13, var11);
int var27 = var11;
for (int var28 = 0; var28 < var12.size(); var28++) {
Holder var16 = (Holder<EntityStore>)var12.get(var28);
UUIDComponent var17 = var16.getComponent(UUIDComponent.getComponentType());
if (var17 == null) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping entity with no UUID component while saving entity section (%d, %d, %d)", var1, var2, var3);
} else {
UUID var18 = var17.getUuid();
MemorySegment var19 = var6.keys(16);
RocksDbChunkStorageProvider.putUuidKey(var19, 0L, var18.getMostSignificantBits(), var18.getLeastSignificantBits());
BsonDocument var20 = EntityStore.REGISTRY.serialize(var16);
int var21 = RocksDbChunkStorageProvider.stageValue(var6, var20);
RocksDbNative.writebatchPutCf(var7, this.db.entityColumn, var19, 16L, var6.value, var21);
var27 += var21;
}
}
long var29 = System.nanoTime();
RocksDbNative.write(this.db.db, this.db.writeOptions, var7, var6.clearErrPtr());
RocksDbChunkStorageProvider.checkError(var6.errPtr);
long var30 = System.nanoTime();
this.saveCount.getAndIncrement();
this.totalBytesSaved.getAndAdd(var27);
this.serializeStats.record(var29 - var8, var27);
this.writeStats.record(var30 - var29, var27);
} catch (RocksDbChunkStorageProvider.RocksDbException var25) {
this.saveFailureCount.getAndIncrement();
throw var25;
} class="kw">finally {
RocksDbNative.writebatchClear(var7);
}
}
)
);
ObjectListIterator var16 = var13.iterator();
while (var16.hasNext()) {
Dirty var17 = (Dirty)var16.next();
var17.setSaving(var14);
}
var15 = true;
} class="kw">finally {
if (!var15) {
ObjectListIterator var19 = var13.iterator();
while (var19.hasNext()) {
Dirty var20 = (Dirty)var19.next();
var20.markDirty();
}
}
}
if (var7 != null) {
var14.whenComplete((var1x, var2x) -> var7.run());
}
if (var13.isEmpty()) {
class="kw">return var14;
}
ReferenceArrayList var23 = var13;
CompletableFuture var24 = var14;
BiConsumer var18 = (var2x, var3x) -> {
if (var3x != null) {
Iterator var4 = var23.iterator();
while (var4.hasNext()) {
Dirty var5 = (Dirty)var4.next();
var5.markDirty();
}
}
Iterator var6 = var23.iterator();
while (var6.hasNext()) {
Dirty var7 = (Dirty)var6.next();
var7.clearSaving(var24);
}
};
class="kw">return var6 != null ? var14.whenCompleteAsync(var18, var6) : var14.whenComplete(var18);
}
@Override
class="kw">public CompletableFuture<Void> saveEntity(UUID var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3) {
Holder var4 = var2.copySerializableEntity(var3);
class="kw">return this.db.runIo(SneakyThrow.sneakyRunnable(() -> {
RocksDbChunkStorageProvider.Scratch var3 = RocksDbChunkStorageProvider.SCRATCH.get();
long var4 = System.nanoTime();
try {
MemorySegment var6 = var3.keys(16);
RocksDbChunkStorageProvider.putUuidKey(var6, 0L, var1.getMostSignificantBits(), var1.getLeastSignificantBits());
BsonDocument var7 = EntityStore.REGISTRY.serialize(var4);
int var8 = RocksDbChunkStorageProvider.stageValue(var3, var7);
long var9 = System.nanoTime();
RocksDbNative.putCf(this.db.db, this.db.writeOptions, this.db.entityColumn, var6, 16L, var3.value, var8, var3.clearErrPtr());
RocksDbChunkStorageProvider.checkError(var3.errPtr);
long var11 = System.nanoTime();
this.saveCount.getAndIncrement();
this.totalBytesSaved.getAndAdd(var8);
this.serializeStats.record(var9 - var4, var8);
this.writeStats.record(var11 - var9, var8);
} catch (RocksDbChunkStorageProvider.RocksDbException var13) {
this.saveFailureCount.getAndIncrement();
throw var13;
}
}));
}
@Nonnull
@Override
class="kw">public CompletableFuture<Void> removeEntity(@Nonnull UUID var1) {
class="kw">return this.db.runIo(SneakyThrow.sneakyRunnable(() -> {
RocksDbChunkStorageProvider.Scratch var2 = RocksDbChunkStorageProvider.SCRATCH.get();
MemorySegment var3 = var2.keys(16);
RocksDbChunkStorageProvider.putUuidKey(var3, 0L, var1.getMostSignificantBits(), var1.getLeastSignificantBits());
long var4 = System.nanoTime();
try {
RocksDbNative.deleteCf(this.db.db, this.db.writeOptions, this.db.entityColumn, var3, 16L, var2.clearErrPtr());
RocksDbChunkStorageProvider.checkError(var2.errPtr);
} catch (RocksDbChunkStorageProvider.RocksDbException var8) {
this.removeFailureCount.getAndIncrement();
throw var8;
}
long var6 = System.nanoTime() - var4;
this.removeCount.getAndIncrement();
this.removeStats.record(var6, 0L);
}));
}
@Nullable
class="kw">private class="kw">static RocksDbChunkStorageProvider.Saver.BlockComponentsToSave prepareBlockComponentsToSave(
@Nullable BlockComponentSection var0,
boolean var1,
@Nonnull ReferenceArrayList<BlockComponentSection> var2,
@Nonnull ReferenceArrayList<RocksDbChunkStorageProvider.Saver.BlockComponentsToSave> var3
) {
if (var0 == null) {
class="kw">return null;
}
if (var1) {
var0.markAllBlocksNeedsSaving();
}
if (!var0.isSaving() && var0.consumeNeedsSaving()) {
var0.setSaving(true);
var2.add(var0);
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var4 = snapshotBlockComponents(var0);
if (var4 != null) {
var3.add(var4);
}
class="kw">return var4;
} else {
class="kw">return null;
}
}
@Nullable
class="kw">private class="kw">static RocksDbChunkStorageProvider.Saver.BlockComponentsToSave snapshotBlockComponents(@Nonnull BlockComponentSection var0) {
ShortSet var1 = var0.takeRemovedBlocks();
ShortSet var2 = var0.takeDirtyBlocks();
if (var1 == null && var2 == null) {
class="kw">return null;
}
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var3 = new RocksDbChunkStorageProvider.Saver.BlockComponentsToSave(var0, var2, var1, false);
try {
if (var1 != null) {
var3.deletes.addAll(var1);
}
if (var2 != null) {
ComponentRegistry.Data var4 = ChunkStore.REGISTRY.getData();
ShortIterator var5 = var2.iterator();
while (var5.hasNext()) {
short var6 = var5.nextShort();
Ref var7 = var0.getBlockReference(var6);
if (var7 != null && var7.isValid()) {
Store var10 = var7.getStore();
if (var10.getArchetype(var7).hasSerializableComponents(var4)) {
var3.putIndexes.add(var6);
var3.putHolders.add(var10.copySerializableEntity(var7));
} else {
var3.deleteDirtyIndex(var6);
}
} else {
Holder var8 = var0.getBlockHolder(var6);
if (var8 != null && var8.hasSerializableComponents(var4)) {
var3.putIndexes.add(var6);
var3.putHolders.add(var8.cloneSerializable(var4));
} else {
var3.deleteDirtyIndex(var6);
}
}
}
}
class="kw">return var3;
} catch (Throwable var9) {
var3.restore();
throw var9;
}
}
class="kw">private class="kw">static int writeBlockComponentRows(
@Nonnull RocksDbChunkStorageProvider.Scratch var0,
@Nonnull MemorySegment var1,
@Nonnull MemorySegment var2,
int var3,
int var4,
int var5,
@Nonnull RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var6
) {
MemorySegment var7 = var0.keys(38);
long var8 = 24L;
if (var6.replaceAll) {
RocksDbChunkStorageProvider.putSectionKey(var7, 0L, var3, var4, var5);
RocksDbChunkStorageProvider.putSectionKey(var7, 12L, var3, var4 + 1, var5);
RocksDbNative.writebatchDeleteRangeCf(var1, var2, var7.asSlice(0L, 12L), 12L, var7.asSlice(12L, 12L), 12L);
}
for (int var10 = 0; var10 < var6.deletes.size(); var10++) {
RocksDbChunkStorageProvider.putBlockComponentKey(var7, 24L, var3, var4, var5, var6.deletes.getShort(var10));
RocksDbNative.writebatchDeleteCf(var1, var2, var7.asSlice(24L, 14L), 14L);
}
int var14 = 0;
for (int var11 = 0; var11 < var6.putIndexes.size(); var11++) {
RocksDbChunkStorageProvider.putBlockComponentKey(var7, 24L, var3, var4, var5, var6.putIndexes.getShort(var11));
BsonDocument var12 = ChunkStore.REGISTRY.serialize((Holder<ChunkStore>)var6.putHolders.get(var11));
int var13 = RocksDbChunkStorageProvider.stageValue(var0, var12);
RocksDbNative.writebatchPutCf(var1, var2, var7.asSlice(24L, 14L), 14L, var0.value, var13);
var14 += var13;
}
class="kw">return var14;
}
@Override
class="kw">public CompletableFuture<Void> saveBlockComponentSection(
int var1, int var2, int var3, @Nonnull Store<ChunkStore> var4, @Nonnull BlockComponentSection var5, @Nullable Executor var6, @Nullable Runnable var7
) {
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var8 = null;
boolean var10 = false;
CompletableFuture var9;
try {
var8 = snapshotBlockComponents(var5);
if (var8 == null) {
var9 = CompletableFuture.completedFuture(null);
} else {
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var11 = var8;
var9 = this.db.runIo(SneakyThrow.sneakyRunnable(() -> {
RocksDbChunkStorageProvider.Scratch var5 = RocksDbChunkStorageProvider.SCRATCH.get();
MemorySegment var6 = var5.writeBatch();
long var7 = System.nanoTime();
try {
int var9 = writeBlockComponentRows(var5, var6, this.db.blockComponentColumn, var1, var2, var3, var11);
long var10 = System.nanoTime();
RocksDbNative.write(this.db.db, this.db.writeOptions, var6, var5.clearErrPtr());
RocksDbChunkStorageProvider.checkError(var5.errPtr);
long var12 = System.nanoTime();
this.saveCount.getAndIncrement();
this.totalBytesSaved.getAndAdd(var9);
this.serializeStats.record(var10 - var7, var9);
this.writeStats.record(var12 - var10, var9);
} catch (RocksDbChunkStorageProvider.RocksDbException var17) {
this.saveFailureCount.getAndIncrement();
throw var17;
} class="kw">finally {
RocksDbNative.writebatchClear(var6);
}
}));
}
var10 = true;
} class="kw">finally {
if (!var10 && var8 != null) {
var8.restore();
}
}
if (var7 != null) {
var9.whenComplete((var1x, var2x) -> var7.run());
}
if (var8 == null) {
class="kw">return var9;
}
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var15 = var8;
BiConsumer var12 = (var1x, var2x) -> {
if (var2x != null) {
var15.restore();
}
};
class="kw">return var6 != null ? var9.whenCompleteAsync(var12, var6) : var9.whenComplete(var12);
}
@Nonnull
@Override
class="kw">public CompletableFuture<Void> saveChunkColumn(
int var1, int var2, @Nonnull Store<ChunkStore> var3, @Nonnull Ref<ChunkStore> var4, @Nullable Executor var5, @Nullable Runnable var6
) {
ReferenceArrayList var7 = new ReferenceArrayList(10);
ReferenceArrayList var8 = new ReferenceArrayList(10);
ReferenceArrayList var9 = new ReferenceArrayList(10);
ReferenceArrayList var10 = new ReferenceArrayList(10);
ReferenceArrayList var11 = new ReferenceArrayList(10);
boolean var13 = false;
CompletableFuture var12;
try {
ReferenceArrayList var14 = new ReferenceArrayList();
ChunkColumn var15 = var3.getComponent(var4, ChunkColumn.getComponentType());
assert var15 != null;
Holder[] var16 = var15.getSectionHolders();
WorldChunk var17 = var3.getComponent(var4, WorldChunk.getComponentType());
assert var17 != null;
boolean var18 = !var17.is(ChunkFlag.ON_DISK);
ReferenceArrayList var19 = new ReferenceArrayList();
ComponentRegistry.Data var20 = EntityStore.REGISTRY.getData();
ComponentRegistry.Data var21 = ChunkStore.REGISTRY.getData();
if (var16 != null) {
for (int var37 = 0; var37 < var16.length; var37++) {
Holder var39 = var16[var37];
if (var39 != null) {
Holder var41 = null;
ChunkSection var43 = var39.getComponent(ChunkSection.getComponentType());
if (!var43.isSaving() && (var43.consumeNeedsSaving() || var18)) {
var43.setSaving(true);
var7.add(var43);
var41 = var39.cloneSerializable(
var21, var0 -> !var0.equals(EntitySection.getComponentType()) && !var0.equals(BlockComponentSection.getComponentType())
);
}
List var44 = null;
EntitySection var45 = var39.getComponent(EntitySection.getComponentType());
if (var45 != null) {
List var46 = var45.getEntityHolders();
if (!var45.isSaving() && var45.consumeNeedsSaving()) {
var45.setSaving(true);
var8.add(var45);
var44 = new ObjectArrayList(var46.size());
collectEntityUuidsFromHolders(var46, var20, var44);
}
snapshotDirtyEntityHolders(var46, var20, var19, var11);
}
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var47 = prepareBlockComponentsToSave(
var39.getComponent(BlockComponentSection.getComponentType()), var18, var9, var10
);
if (var41 != null || var44 != null || var47 != null) {
var14.add(new RocksDbChunkStorageProvider.Saver.SectionToSave(var1, var37, var2, var41, var44, var47));
}
}
}
} else {
Ref[] var22 = var15.getSections();
for (int var23 = 0; var23 < var22.length; var23++) {
Ref var24 = var22[var23];
if (var24 != null && var24.isValid()) {
Holder var25 = null;
ChunkSection var26 = var3.getComponent(var24, ChunkSection.getComponentType());
if (!var26.isSaving() && (var26.consumeNeedsSaving() || var18)) {
var26.setSaving(true);
var7.add(var26);
var25 = var3.copySerializableEntity(
var24,
ChunkStore.REGISTRY.newHolder(),
var0 -> !var0.equals(EntitySection.getComponentType()) && !var0.equals(BlockComponentSection.getComponentType())
);
}
List var27 = null;
EntitySection var28 = var3.getComponent(var24, EntitySection.getComponentType());
if (var28 != null) {
List var29 = var28.getEntityHolders();
Set var30 = var28.getEntityReferences();
if (!var28.isSaving() && var28.consumeNeedsSaving()) {
var28.setSaving(true);
var8.add(var28);
var27 = new ObjectArrayList(var29.size() + var30.size());
collectEntityUuidsFromHolders(var29, var20, var27);
collectEntityUuidsFromReferences(var30, var20, var27);
}
snapshotDirtyEntityHolders(var29, var20, var19, var11);
snapshotDirtyEntityReferences(var30, var20, var19, var11);
}
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var48 = prepareBlockComponentsToSave(
var3.getComponent(var24, BlockComponentSection.getComponentType()), var18, var9, var10
);
if (var25 != null || var27 != null || var48 != null) {
var14.add(new RocksDbChunkStorageProvider.Saver.SectionToSave(var1, var23, var2, var25, var27, var48));
}
}
}
}
Holder var38 = var3.copySerializableEntity(var4, ChunkStore.REGISTRY.newHolder(), var0 -> !var0.equals(ChunkColumn.getComponentType()));
var12 = this.submitChunkColumnBatch(var1, var2, var38, var14, var19);
ObjectListIterator var40 = var11.iterator();
while (var40.hasNext()) {
Dirty var42 = (Dirty)var40.next();
var42.setSaving(var12);
}
var13 = true;
} class="kw">finally {
if (!var13) {
ObjectListIterator var32 = var7.iterator();
while (var32.hasNext()) {
ChunkSection var33 = (ChunkSection)var32.next();
var33.markNeedsSaving();
var33.setSaving(false);
}
var32 = var8.iterator();
while (var32.hasNext()) {
EntitySection var53 = (EntitySection)var32.next();
var53.markNeedsSaving();
var53.setSaving(false);
}
var32 = var9.iterator();
while (var32.hasNext()) {
BlockComponentSection var54 = (BlockComponentSection)var32.next();
var54.markNeedsSaving();
var54.setSaving(false);
}
var32 = var10.iterator();
while (var32.hasNext()) {
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var55 = (RocksDbChunkStorageProvider.Saver.BlockComponentsToSave)var32.next();
var55.restore();
}
var32 = var11.iterator();
while (var32.hasNext()) {
Dirty var56 = (Dirty)var32.next();
var56.markDirty();
}
}
}
if (var6 != null) {
var12.whenComplete((var1x, var2x) -> var6.run());
}
if (var7.isEmpty() && var8.isEmpty() && var9.isEmpty() && var11.isEmpty()) {
class="kw">return var12;
}
BiConsumer var36 = (var6x, var7x) -> {
if (var7x != null) {
Iterator var8 = var7.iterator();
while (var8.hasNext()) {
ChunkSection var9 = (ChunkSection)var8.next();
var9.markNeedsSaving();
}
var8 = var8.iterator();
while (var8.hasNext()) {
EntitySection var18 = (EntitySection)var8.next();
var18.markNeedsSaving();
}
var8 = var9.iterator();
while (var8.hasNext()) {
BlockComponentSection var19 = (BlockComponentSection)var8.next();
var19.markNeedsSaving();
}
var8 = var10.iterator();
while (var8.hasNext()) {
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var20 = (RocksDbChunkStorageProvider.Saver.BlockComponentsToSave)var8.next();
var20.restore();
}
var8 = var11.iterator();
while (var8.hasNext()) {
Dirty var21 = (Dirty)var8.next();
var21.markDirty();
}
}
Iterator var14 = var7.iterator();
while (var14.hasNext()) {
ChunkSection var22 = (ChunkSection)var14.next();
var22.setSaving(false);
}
var14 = var8.iterator();
while (var14.hasNext()) {
EntitySection var23 = (EntitySection)var14.next();
var23.setSaving(false);
}
var14 = var9.iterator();
while (var14.hasNext()) {
BlockComponentSection var24 = (BlockComponentSection)var14.next();
var24.setSaving(false);
}
var14 = var11.iterator();
while (var14.hasNext()) {
Dirty var25 = (Dirty)var14.next();
var25.clearSaving(var12);
}
};
class="kw">return var5 != null ? var12.whenCompleteAsync(var36, var5) : var12.whenComplete(var36);
}
class="kw">private class="kw">static void collectEntityUuidsFromHolders(
@Nonnull List<Holder<EntityStore>> var0, @Nonnull ComponentRegistry.Data<EntityStore> var1, @Nonnull List<UUID> var2
) {
for (int var3 = 0; var3 < var0.size(); var3++) {
Holder var4 = var0.get(var3);
if (var4.hasSerializableComponents(var1)) {
UUIDComponent var5 = var4.ensureAndGetComponent(UUIDComponent.getComponentType());
var2.add(var5.getUuid());
}
}
}
class="kw">private class="kw">static void snapshotDirtyEntityHolders(
@Nonnull List<Holder<EntityStore>> var0,
@Nonnull ComponentRegistry.Data<EntityStore> var1,
@Nonnull List<Holder<EntityStore>> var2,
@Nonnull List<Dirty> var3
) {
for (int var4 = 0; var4 < var0.size(); var4++) {
Holder var5 = var0.get(var4);
if (var5.hasSerializableComponents(var1)) {
Dirty var6 = var5.getComponent(Dirty.getComponentType());
if (var6 != null) {
if (var6.isSaving() || !var6.isDirty()) {
class="kw">continue;
}
var3.add(var6);
var6.consumeDirty();
}
var2.add(var5.cloneSerializable(var1));
}
}
}
class="kw">private class="kw">static void collectEntityUuidsFromReferences(
@Nonnull Iterable<Ref<EntityStore>> var0, @Nonnull ComponentRegistry.Data<EntityStore> var1, @Nonnull List<UUID> var2
) {
for (Ref var4 : var0) {
Store var5 = var4.getStore();
if (var5.getArchetype(var4).hasSerializableComponents(var1)) {
UUIDComponent var6 = var5.getComponent(var4, UUIDComponent.getComponentType());
assert var6 != null;
var2.add(var6.getUuid());
}
}
}
class="kw">private class="kw">static void snapshotDirtyEntityReferences(
@Nonnull Iterable<Ref<EntityStore>> var0,
@Nonnull ComponentRegistry.Data<EntityStore> var1,
@Nonnull List<Holder<EntityStore>> var2,
@Nonnull List<Dirty> var3
) {
for (Ref var5 : var0) {
Store var6 = var5.getStore();
if (var6.getArchetype(var5).hasSerializableComponents(var1)) {
Dirty var7 = var6.getComponent(var5, Dirty.getComponentType());
if (var7 != null) {
if (var7.isSaving() || !var7.isDirty()) {
class="kw">continue;
}
var3.add(var7);
var7.consumeDirty();
}
var2.add(var6.copySerializableEntity(var5));
}
}
}
@Nonnull
@Override
class="kw">public CompletableFuture<Void> saveHolder(int var1, int var2, @Nonnull Holder<ChunkStore> var3) {
ReferenceArrayList var4 = new ReferenceArrayList();
ChunkColumn var5 = var3.getComponent(ChunkColumn.getComponentType());
var3.removeComponent(ChunkColumn.getComponentType());
ReferenceArrayList var6 = new ReferenceArrayList();
if (var5 != null) {
Holder[] var7 = var5.getSectionHolders();
if (var7 != null) {
for (int var8 = 0; var8 < var7.length; var8++) {
Holder var9 = var7[var8];
if (var9 != null) {
List var10 = null;
EntitySection var11 = var9.getComponent(EntitySection.getComponentType());
if (var11 != null) {
List var12 = var11.getEntityHolders();
var10 = new ObjectArrayList(var12.size());
for (int var13 = 0; var13 < var12.size(); var13++) {
Holder var14 = var12.get(var13);
UUIDComponent var15 = var14.ensureAndGetComponent(UUIDComponent.getComponentType());
var10.add(var15.getUuid());
var6.add(var14);
}
}
RocksDbChunkStorageProvider.Saver.BlockComponentsToSave var16 = null;
BlockComponentSection var17 = var9.getComponent(BlockComponentSection.getComponentType());
if (var17 != null) {
var16 = new RocksDbChunkStorageProvider.Saver.BlockComponentsToSave(null, null, null, true);
ObjectIterator var18 = var17.getBlockHolders().short2ObjectEntrySet().iterator();
while (var18.hasNext()) {
Entry var19 = (Entry<Holder<ChunkStore>>)var18.next();
var16.putIndexes.add(var19.getShortKey());
var16.putHolders.add((Holder)var19.getValue());
}
}
var9.tryRemoveComponent(EntitySection.getComponentType());
var9.tryRemoveComponent(BlockComponentSection.getComponentType());
var4.add(new RocksDbChunkStorageProvider.Saver.SectionToSave(var1, var8, var2, var9, var10, var16));
}
}
}
}
class="kw">return this.submitChunkColumnBatch(var1, var2, var3, var4, var6);
}
class="kw">private CompletableFuture<Void> submitChunkColumnBatch(
int var1,
int var2,
@Nonnull Holder<ChunkStore> var3,
@Nonnull List<RocksDbChunkStorageProvider.Saver.SectionToSave> var4,
@Nonnull List<Holder<EntityStore>> var5
) {
class="kw">return this.db
.runIo(
SneakyThrow.sneakyRunnable(
() -> {
RocksDbChunkStorageProvider.Scratch var6 = RocksDbChunkStorageProvider.SCRATCH.get();
MemorySegment var7 = var6.writeBatch();
long var8 = System.nanoTime();
try {
BsonDocument var10 = ChunkStore.REGISTRY.serialize(var3);
MemorySegment var11 = var6.keys(8);
RocksDbChunkStorageProvider.putChunkKey(var11, 0L, var1, var2);
int var12 = RocksDbChunkStorageProvider.stageValue(var6, var10);
RocksDbNative.writebatchPutCf(var7, this.db.chunkColumn, var11, 8L, var6.value, var12);
int var13 = var12;
for (int var14 = 0; var14 < var4.size(); var14++) {
RocksDbChunkStorageProvider.Saver.SectionToSave var15 = var4.get(var14);
Holder var16 = var15.section;
if (var16 != null) {
BsonDocument var17 = ChunkStore.REGISTRY.serialize(var16);
MemorySegment var18 = var6.keys(12);
RocksDbChunkStorageProvider.putSectionKey(var18, 0L, var15.x, var15.y, var15.z);
int var19 = RocksDbChunkStorageProvider.stageValue(var6, var17);
RocksDbNative.writebatchPutCf(var7, this.db.sectionColumn, var18, 12L, var6.value, var19);
var13 += var19;
}
if (var15.entities != null) {
int var33 = var15.entities.size();
int var35 = 16 * var33;
MemorySegment var37 = var6.keys(12);
RocksDbChunkStorageProvider.putSectionKey(var37, 0L, var15.x, var15.y, var15.z);
MemorySegment var20 = var6.value(var35);
for (int var21 = 0; var21 < var33; var21++) {
UUID var22 = var15.entities.get(var21);
RocksDbChunkStorageProvider.putUuidKey(var20, var21 * 16L, var22.getMostSignificantBits(), var22.getLeastSignificantBits());
}
RocksDbNative.writebatchPutCf(var7, this.db.entitySectionColumn, var37, 12L, var20, var35);
var13 += var35;
}
if (var15.blockComponents != null) {
var13 += writeBlockComponentRows(var6, var7, this.db.blockComponentColumn, var15.x, var15.y, var15.z, var15.blockComponents);
}
}
for (int var28 = 0; var28 < var5.size(); var28++) {
Holder var30 = var5.get(var28);
UUIDComponent var31 = var30.getComponent(UUIDComponent.getComponentType());
if (var31 == null) {
RocksDbChunkStorageProvider.LOGGER
.at(Level.WARNING)
.log("Skipping entity with no UUID component while saving chunk column (%d, %d)", var1, var2);
} else {
UUID var34 = var31.getUuid();
MemorySegment var36 = var6.keys(16);
RocksDbChunkStorageProvider.putUuidKey(var36, 0L, var34.getMostSignificantBits(), var34.getLeastSignificantBits());
BsonDocument var38 = EntityStore.REGISTRY.serialize(var30);
int var39 = RocksDbChunkStorageProvider.stageValue(var6, var38);
RocksDbNative.writebatchPutCf(var7, this.db.entityColumn, var36, 16L, var6.value, var39);
var13 += var39;
}
}
long var29 = System.nanoTime();
RocksDbNative.write(this.db.db, this.db.writeOptions, var7, var6.clearErrPtr());
RocksDbChunkStorageProvider.checkError(var6.errPtr);
long var32 = System.nanoTime();
this.saveCount.getAndIncrement();
this.totalBytesSaved.getAndAdd(var13);
this.serializeStats.record(var29 - var8, var13);
this.writeStats.record(var32 - var29, var13);
} catch (RocksDbChunkStorageProvider.RocksDbException var26) {
this.saveFailureCount.getAndIncrement();
throw var26;
} class="kw">finally {
RocksDbNative.writebatchClear(var7);
}
}
)
);
}
@Nonnull
@Override
class="kw">public CompletableFuture<Void> removeHolder(int var1, int var2) {
class="kw">return this.db.runIo(SneakyThrow.sneakyRunnable(() -> {
RocksDbChunkStorageProvider.Scratch var3 = RocksDbChunkStorageProvider.SCRATCH.get();
MemorySegment var4 = var3.keys(32);
long var5 = 8L;
long var7 = 20L;
RocksDbChunkStorageProvider.putChunkKey(var4, 0L, var1, var2);
RocksDbChunkStorageProvider.putSectionKey(var4, 8L, var1, 0, var2);
RocksDbChunkStorageProvider.putSectionKey(var4, 20L, var1, 10, var2);
long var9 = System.nanoTime();
MemorySegment var11 = var3.writeBatch();
try {
RocksDbNative.writebatchDeleteCf(var11, this.db.chunkColumn, var4.asSlice(0L, 8L), 8L);
MemorySegment var12 = var4.asSlice(8L, 12L);
MemorySegment var13 = var4.asSlice(20L, 12L);
RocksDbNative.writebatchDeleteRangeCf(var11, this.db.sectionColumn, var12, 12L, var13, 12L);
RocksDbNative.writebatchDeleteRangeCf(var11, this.db.entitySectionColumn, var12, 12L, var13, 12L);
RocksDbNative.writebatchDeleteRangeCf(var11, this.db.blockComponentColumn, var12, 12L, var13, 12L);
RocksDbNative.write(this.db.db, this.db.writeOptions, var11, var3.clearErrPtr());
RocksDbChunkStorageProvider.checkError(var3.errPtr);
} catch (RocksDbChunkStorageProvider.RocksDbException var17) {
this.removeFailureCount.getAndIncrement();
throw var17;
} class="kw">finally {
RocksDbNative.writebatchClear(var11);
}
long var19 = System.nanoTime() - var9;
this.removeCount.getAndIncrement();
this.removeStats.record(var19, 0L);
}));
}
@Nonnull
@Override
class="kw">public LongList getIndexes() class="kw">throws IOException {
class="kw">return RocksDbChunkStorageProvider.chunkIndexesFromColumn(this.db);
}
@Override
class="kw">public void flush() class="kw">throws IOException {
try (Arena var1 = Arena.ofConfined()) {
MemorySegment var2 = var1.allocate(RocksDbNative.C_POINTER);
var2.set(RocksDbNative.C_POINTER, 0L, MemorySegment.NULL);
RocksDbNative.flush(this.db.db, this.db.flushOptions, var2);
try {
RocksDbChunkStorageProvider.checkError(var2);
} catch (RocksDbChunkStorageProvider.RocksDbException var5) {
throw new IOException(var5);
}
this.flushCount.getAndIncrement();
}
}
@Nonnull
@Override
class="kw">public CompletableFuture<Void> compact(@Nullable long[] var1) {
class="kw">return this.db.runIo(SneakyThrow.sneakyRunnable(() -> {
byte[] var2 = null;
byte[] var3 = null;
if (var1 != null && var1.length > 0) {
byte[] var4 = null;
byte[] var5 = null;
for (long var9 : var1) {
byte[] var11 = RocksDbChunkStorageProvider.toKey(ChunkUtil.xOfChunkIndex(var9), ChunkUtil.zOfChunkIndex(var9));
if (var4 == null || Arrays.compareUnsigned(var11, var4) < 0) {
var4 = var11;
}
if (var5 == null || Arrays.compareUnsigned(var11, var5) > 0) {
var5 = var11;
}
}
var2 = var4;
var3 = new byte[var5.length + 1];
System.arraycopy(var5, 0, var3, 0, var5.length);
}
try (Arena var19 = Arena.ofConfined()) {
MemorySegment var20 = RocksDbNative.compactoptionsCreate();
try {
RocksDbNative.compactoptionsSetBottommostLevelCompaction(var20, (byte)3);
MemorySegment var21 = RocksDbChunkStorageProvider.toNativeKey(var19, var2);
long var22 = var2 == null ? 0L : var2.length;
MemorySegment var23 = RocksDbChunkStorageProvider.toNativeKey(var19, var3);
long var10 = var3 == null ? 0L : var3.length;
RocksDbNative.compactRangeCfOpt(this.db.db, this.db.chunkColumn, var20, var21, var22, var23, var10);
RocksDbNative.compactRangeCfOpt(this.db.db, this.db.sectionColumn, var20, var21, var22, var23, var10);
RocksDbNative.compactRangeCfOpt(this.db.db, this.db.entitySectionColumn, var20, var21, var22, var23, var10);
RocksDbNative.compactRangeCfOpt(this.db.db, this.db.blockComponentColumn, var20, var21, var22, var23, var10);
if (var2 == null) {
RocksDbNative.compactRangeCfOpt(this.db.db, this.db.entityColumn, var20, MemorySegment.NULL, 0L, MemorySegment.NULL, 0L);
}
this.compactCount.getAndIncrement();
} class="kw">finally {
RocksDbNative.compactoptionsDestroy(var20);
}
}
}));
}
@Override
class="kw">public void close() class="kw">throws IOException {
}
@Override
class="kw">public void pauseBackgroundSaving(ChunkSavingSystems.Data var1) {
var1.pushSavingFuture(this.db.runIo(SneakyThrow.sneakyRunnable(() -> {
try (Arena var1 = Arena.ofConfined()) {
MemorySegment var2 = var1.allocate(RocksDbNative.C_POINTER);
var2.set(RocksDbNative.C_POINTER, 0L, MemorySegment.NULL);
RocksDbNative.pauseBackgroundWork(this.db.db, var2);
RocksDbChunkStorageProvider.checkError(var2);
}
})));
}
@Nonnull
@Override
class="kw">public CompletableFuture<Void> resumeBackgroundSaving() {
class="kw">return this.db.runIo(SneakyThrow.sneakyRunnable(() -> {
try (Arena var1 = Arena.ofConfined()) {
MemorySegment var2 = var1.allocate(RocksDbNative.C_POINTER);
var2.set(RocksDbNative.C_POINTER, 0L, MemorySegment.NULL);
RocksDbNative.continueBackgroundWork(this.db.db, var2);
RocksDbChunkStorageProvider.checkError(var2);
}
}));
}
@Nonnull
@Override
class="kw">public MetricResults toMetricResults() {
class="kw">return METRICS_REGISTRY.toMetricResults(this);
}
class="kw">private class="kw">static class="kw">final class BlockComponentsToSave {
@Nullable
class="kw">private class="kw">final BlockComponentSection section;
@Nullable
class="kw">private class="kw">final ShortSet dirty;
@Nullable
class="kw">private ShortSet removed;
class="kw">private class="kw">final boolean replaceAll;
class="kw">private class="kw">final ShortArrayList deletes = new ShortArrayList();
class="kw">private class="kw">final ShortArrayList putIndexes = new ShortArrayList();
class="kw">private class="kw">final ObjectArrayList<Holder<ChunkStore>> putHolders = new ObjectArrayList();
class="kw">private BlockComponentsToSave(@Nullable BlockComponentSection var1, @Nullable ShortSet var2, @Nullable ShortSet var3, boolean var4) {
this.section = var1;
this.dirty = var2;
this.removed = var3;
this.replaceAll = var4;
}
class="kw">private void deleteDirtyIndex(short var1) {
this.deletes.add(var1);
if (this.removed == null) {
this.removed = new ShortOpenHashSet();
}
this.removed.add(var1);
}
class="kw">private void restore() {
if (this.section != null) {
this.section.restoreSaveFailure(this.dirty, this.removed);
}
}
}
class="kw">private record SectionToSave(
int x,
int y,
int z,
@Nullable Holder<ChunkStore> section,
@Nullable List<UUID> entities,
@Nullable RocksDbChunkStorageProvider.Saver.BlockComponentsToSave blockComponents
) {
class="kw">private SectionToSave {
}
}
}
class="kw">private class="kw">static class="kw">final class Scratch {
class="kw">private class="kw">final MemorySegment errPtr = Arena.ofAuto().allocate(RocksDbNative.C_POINTER);
class="kw">private MemorySegment keys = Arena.ofAuto().allocate(256L);
class="kw">private MemorySegment value = Arena.ofAuto().allocate(8192L);
class="kw">private MemorySegment cfPtrs = Arena.ofAuto().allocate(RocksDbNative.C_POINTER, 8L);
class="kw">private MemorySegment keyPtrs = Arena.ofAuto().allocate(RocksDbNative.C_POINTER, 8L);
class="kw">private MemorySegment keyLens = Arena.ofAuto().allocate(RocksDbNative.C_SIZE_T, 8L);
class="kw">private MemorySegment valuePtrs = Arena.ofAuto().allocate(RocksDbNative.C_POINTER, 8L);
class="kw">private MemorySegment valueLens = Arena.ofAuto().allocate(RocksDbNative.C_SIZE_T, 8L);
class="kw">private MemorySegment errs = Arena.ofAuto().allocate(RocksDbNative.C_POINTER, 8L);
class="kw">private int arrayCapacity = 8;
class="kw">private class="kw">final BasicOutputBuffer bson = new BasicOutputBuffer();
class="kw">private MemorySegment writeBatch;
class="kw">private Scratch() {
}
class="kw">private MemorySegment clearErrPtr() {
this.errPtr.set(RocksDbNative.C_POINTER, 0L, MemorySegment.NULL);
class="kw">return this.errPtr;
}
class="kw">private MemorySegment keys(int var1) {
if (var1 < 0) {
throw new IllegalArgumentException("negative key scratch size: " + var1);
}
if (this.keys.byteSize() < var1) {
this.keys = Arena.ofAuto().allocate(Math.max(var1, this.keys.byteSize() * 2L));
}
class="kw">return this.keys;
}
class="kw">private MemorySegment value(int var1) {
if (var1 < 0) {
throw new IllegalArgumentException("negative value scratch size: " + var1);
}
if (this.value.byteSize() < var1) {
this.value = Arena.ofAuto().allocate(Math.max(var1, this.value.byteSize() * 2L));
}
class="kw">return this.value;
}
class="kw">private void ensureArrays(int var1) {
if (var1 < 0) {
throw new IllegalArgumentException("negative multiGet count: " + var1);
}
if (this.arrayCapacity < var1) {
int var2 = Math.max(var1, this.arrayCapacity * 2);
this.cfPtrs = Arena.ofAuto().allocate(RocksDbNative.C_POINTER, var2);
this.keyPtrs = Arena.ofAuto().allocate(RocksDbNative.C_POINTER, var2);
this.keyLens = Arena.ofAuto().allocate(RocksDbNative.C_SIZE_T, var2);
this.valuePtrs = Arena.ofAuto().allocate(RocksDbNative.C_POINTER, var2);
this.valueLens = Arena.ofAuto().allocate(RocksDbNative.C_SIZE_T, var2);
this.errs = Arena.ofAuto().allocate(RocksDbNative.C_POINTER, var2);
this.arrayCapacity = var2;
}
}
class="kw">private MemorySegment writeBatch() {
if (this.writeBatch == null) {
this.writeBatch = RocksDbNative.writebatchCreate();
} else {
RocksDbNative.writebatchClear(this.writeBatch);
}
class="kw">return this.writeBatch;
}
class="kw">private void destroy() {
if (this.writeBatch != null) {
RocksDbNative.writebatchDestroy(this.writeBatch);
this.writeBatch = null;
}
}
}
}