CalculateAverage_gonixunsafe: an attempt in the unsafe category (#695)
Co-authored-by: Giedrius D <d.giedrius@gmail.com>
This commit is contained in:
gonix
GitHub
@@ -0,0 +1,553 @@
|
||||
/*
|
||||
* Copyright 2023 The original authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package dev.morling.onebrc;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.RandomAccessFile;
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.reflect.Field;
|
||||
import java.nio.channels.FileChannel;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
import sun.misc.Unsafe;
|
||||
|
||||
public class CalculateAverage_gonixunsafe {
|
||||
|
||||
private static final String FILE = "./measurements.txt";
|
||||
private static final int MAX_THREADS = Runtime.getRuntime().availableProcessors();
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
|
||||
var file = new RandomAccessFile(FILE, "r");
|
||||
|
||||
var chunks = Aggregator.buildChunks(file, MAX_THREADS);
|
||||
var chunksCount = chunks.size();
|
||||
var threads = new Thread[chunksCount];
|
||||
var result = new AtomicReference<Aggregator>();
|
||||
for (int i = 0; i < chunksCount; ++i) {
|
||||
var agg = new Aggregator();
|
||||
var chunk = chunks.get(i);
|
||||
var thread = new Thread(() -> {
|
||||
agg.processChunk(chunk);
|
||||
while (!result.compareAndSet(null, agg)) {
|
||||
Aggregator other = result.getAndSet(null);
|
||||
if (other != null) {
|
||||
agg.merge(other);
|
||||
}
|
||||
}
|
||||
});
|
||||
thread.start();
|
||||
threads[i] = thread;
|
||||
}
|
||||
for (int i = 0; i < chunksCount; ++i) {
|
||||
threads[i].join();
|
||||
}
|
||||
System.out.println(result.get().toString());
|
||||
System.out.close();
|
||||
}
|
||||
|
||||
private static class Aggregator {
|
||||
private static final int MAX_STATIONS = 10_000;
|
||||
private static final int INDEX_SIZE = 256 * 1024 * 8;
|
||||
private static final int INDEX_MASK = (INDEX_SIZE - 1) & ~7;
|
||||
|
||||
private static final int HEADER_SIZE = 8;
|
||||
private static final int MAX_KEY_SIZE = 100;
|
||||
private static final int FLD_COUNT = 0; // long
|
||||
private static final int FLD_SUM = 8; // long
|
||||
private static final int FLD_MIN = 16; // int
|
||||
private static final int FLD_MAX = 20; // int
|
||||
private static final int FLD_HASH = 24; // int
|
||||
private static final int FIELDS_SIZE = 28 + 4; // +padding to align to 8 bytes
|
||||
private static final int MAX_STATION_SIZE = HEADER_SIZE + MAX_KEY_SIZE + FIELDS_SIZE;
|
||||
|
||||
private static final Unsafe UNSAFE;
|
||||
|
||||
static {
|
||||
try {
|
||||
Field unsafe = Unsafe.class.getDeclaredField("theUnsafe");
|
||||
unsafe.setAccessible(true);
|
||||
UNSAFE = (Unsafe) unsafe.get(Unsafe.class);
|
||||
}
|
||||
catch (Throwable e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
private static long alloc(long size) {
|
||||
long addr = UNSAFE.allocateMemory(size);
|
||||
UNSAFE.setMemory(addr, size, (byte) 0);
|
||||
return addr;
|
||||
}
|
||||
|
||||
// Poor man's hash map: hash code to offset in `mem`.
|
||||
private final long indexAddr = alloc(INDEX_SIZE);
|
||||
|
||||
// Contiguous storage of key (station name) and stats fields of all
|
||||
// unique stations.
|
||||
// The idea here is to improve locality so that stats fields would
|
||||
// possibly be already in the CPU cache after we are done comparing
|
||||
// the key.
|
||||
private final long memAddr = alloc(MAX_STATIONS * MAX_STATION_SIZE);
|
||||
private long memUsed = memAddr;
|
||||
private int count = 0;
|
||||
|
||||
static List<Chunk> buildChunks(RandomAccessFile file, int count) throws IOException {
|
||||
var fileSize = file.length();
|
||||
var chunkSize = Math.min(Integer.MAX_VALUE - 512, fileSize / count);
|
||||
if (chunkSize <= 0) {
|
||||
chunkSize = fileSize;
|
||||
}
|
||||
var chunks = new ArrayList<Chunk>((int) (fileSize / chunkSize) + 1);
|
||||
var mmap = file.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, fileSize, Arena.global());
|
||||
var fileStartAddr = mmap.address();
|
||||
var fileEndAddr = mmap.address() + mmap.byteSize();
|
||||
var chunkStartAddr = fileStartAddr;
|
||||
while (chunkStartAddr < fileEndAddr) {
|
||||
var pos = chunkStartAddr + chunkSize;
|
||||
if (pos < fileEndAddr) {
|
||||
while (UNSAFE.getByte(pos) != '\n') {
|
||||
pos += 1;
|
||||
}
|
||||
pos += 1;
|
||||
}
|
||||
else {
|
||||
pos = fileEndAddr;
|
||||
}
|
||||
chunks.add(new Chunk(mmap, chunkStartAddr, pos, fileStartAddr, fileEndAddr));
|
||||
chunkStartAddr = pos;
|
||||
}
|
||||
return chunks;
|
||||
}
|
||||
|
||||
Aggregator processChunk(Chunk chunk) {
|
||||
// As an optimization, we assume that we can read past the end
|
||||
// of file size if as we don't cross page boundary.
|
||||
final int WANT_PADDING = 8;
|
||||
final int PAGE_SIZE = UNSAFE.pageSize();
|
||||
if (((chunk.chunkEndAddr + WANT_PADDING) / PAGE_SIZE) <= (chunk.fileEndAddr / PAGE_SIZE)) {
|
||||
return processChunk(chunk.chunkStartAddr, chunk.chunkEndAddr);
|
||||
}
|
||||
|
||||
// Otherwise, to avoid checking if it is safe to read a whole long
|
||||
// near the end of a chunk, we copy the last couple of lines to a
|
||||
// padded buffer and process that part separately.
|
||||
long pos = Math.max(-1, chunk.chunkEndAddr - WANT_PADDING - 1);
|
||||
while (pos >= 0 && UNSAFE.getByte(pos) != '\n') {
|
||||
pos--;
|
||||
}
|
||||
pos++;
|
||||
if (pos > 0) {
|
||||
processChunk(chunk.chunkStartAddr, pos);
|
||||
}
|
||||
long tailLen = chunk.chunkEndAddr - pos;
|
||||
var tailAddr = alloc(tailLen + WANT_PADDING);
|
||||
UNSAFE.copyMemory(pos, tailAddr, tailLen);
|
||||
processChunk(tailAddr, tailAddr + tailLen);
|
||||
return this;
|
||||
}
|
||||
|
||||
private Aggregator processChunk(long startAddr, long endAddr) {
|
||||
long pos = startAddr;
|
||||
while (pos < endAddr) {
|
||||
|
||||
long start = pos;
|
||||
long keyLong = UNSAFE.getLong(pos);
|
||||
long valueSepMark = valueSepMark(keyLong);
|
||||
if (valueSepMark != 0) {
|
||||
int tailBits = tailBits(valueSepMark);
|
||||
pos += valueOffset(tailBits);
|
||||
// assert (UNSAFE.getByte(pos - 1) == ';') : "Expected ';' (1), pos=" + (pos - startAddr);
|
||||
long tailAndLen = tailAndLen(tailBits, keyLong, pos - start - 1);
|
||||
|
||||
long valueLong = UNSAFE.getLong(pos);
|
||||
int decimalSepMark = decimalSepMark(valueLong);
|
||||
pos += nextKeyOffset(decimalSepMark);
|
||||
// assert (UNSAFE.getByte(pos - 1) == '\n') : "Expected '\\n' (1), pos=" + (pos - startAddr);
|
||||
int measurement = decimalValue(decimalSepMark, valueLong);
|
||||
|
||||
add1(start, tailAndLen, hash(hash1(tailAndLen)), measurement);
|
||||
continue;
|
||||
}
|
||||
|
||||
pos += 8;
|
||||
long keyLong1 = keyLong;
|
||||
keyLong = UNSAFE.getLong(pos);
|
||||
valueSepMark = valueSepMark(keyLong);
|
||||
if (valueSepMark != 0) {
|
||||
int tailBits = tailBits(valueSepMark);
|
||||
pos += valueOffset(tailBits);
|
||||
// assert (UNSAFE.getByte(pos - 1) == ';') : "Expected ';' (2), pos=" + (pos - startAddr);
|
||||
long tailAndLen = tailAndLen(tailBits, keyLong, pos - start - 1);
|
||||
|
||||
long valueLong = UNSAFE.getLong(pos);
|
||||
int decimalSepMark = decimalSepMark(valueLong);
|
||||
pos += nextKeyOffset(decimalSepMark);
|
||||
// assert (UNSAFE.getByte(pos - 1) == '\n') : "Expected '\\n' (2), pos=" + (pos - startAddr);
|
||||
int measurement = decimalValue(decimalSepMark, valueLong);
|
||||
|
||||
add2(start, keyLong1, tailAndLen, hash(hash(hash1(keyLong1), tailAndLen)), measurement);
|
||||
continue;
|
||||
}
|
||||
|
||||
long hash = hash1(keyLong1);
|
||||
do {
|
||||
pos += 8;
|
||||
hash = hash(hash, keyLong);
|
||||
keyLong = UNSAFE.getLong(pos);
|
||||
valueSepMark = valueSepMark(keyLong);
|
||||
} while (valueSepMark == 0);
|
||||
int tailBits = tailBits(valueSepMark);
|
||||
pos += valueOffset(tailBits);
|
||||
// assert (UNSAFE.getByte(pos - 1) == ';') : "Expected ';' (N), pos=" + (pos - startAddr);
|
||||
long tailAndLen = tailAndLen(tailBits, keyLong, pos - start - 1);
|
||||
hash = hash(hash, tailAndLen);
|
||||
|
||||
long valueLong = UNSAFE.getLong(pos);
|
||||
int decimalSepMark = decimalSepMark(valueLong);
|
||||
pos += nextKeyOffset(decimalSepMark);
|
||||
// assert (UNSAFE.getByte(pos - 1) == '\n') : "Expected '\\n' (N), pos=" + (pos - startAddr);
|
||||
int measurement = decimalValue(decimalSepMark, valueLong);
|
||||
|
||||
addN(start, tailAndLen, hash(hash), measurement);
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
private static long hash1(long value) {
|
||||
return value;
|
||||
}
|
||||
|
||||
private static long hash(long hash, long value) {
|
||||
return hash ^ value;
|
||||
}
|
||||
|
||||
private static int hash(long hash) {
|
||||
hash *= 0x9E3779B97F4A7C15L; // Fibonacci hashing multiplier
|
||||
return (int) (hash >>> 39);
|
||||
}
|
||||
|
||||
private static long valueSepMark(long keyLong) {
|
||||
// Seen this trick used in multiple other solutions.
|
||||
// Nice breakdown here: https://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord
|
||||
long match = keyLong ^ 0x3B3B3B3B_3B3B3B3BL; // 3B == ';'
|
||||
match = (match - 0x01010101_01010101L) & (~match & 0x80808080_80808080L);
|
||||
return match;
|
||||
}
|
||||
|
||||
private static int tailBits(long valueSepMark) {
|
||||
return Long.numberOfTrailingZeros(valueSepMark >>> 7);
|
||||
}
|
||||
|
||||
private static int valueOffset(int tailBits) {
|
||||
return (int) (tailBits >>> 3) + 1;
|
||||
}
|
||||
|
||||
private static long tailAndLen(int tailBits, long keyLong, long keyLen) {
|
||||
long tailMask = ~(-1L << tailBits);
|
||||
long tail = keyLong & tailMask;
|
||||
return (tail << 8) | (keyLen & 0xFF);
|
||||
}
|
||||
|
||||
private static int decimalSepMark(long value) {
|
||||
// Seen this trick used in multiple other solutions.
|
||||
// Looks like the original author is @merykitty.
|
||||
|
||||
// The 4th binary digit of the ascii of a digit is 1 while
|
||||
// that of the '.' is 0. This finds the decimal separator
|
||||
// The value can be 12, 20, 28
|
||||
return Long.numberOfTrailingZeros(~value & 0x10101000);
|
||||
}
|
||||
|
||||
private static int decimalValue(int decimalSepMark, long value) {
|
||||
// Seen this trick used in multiple other solutions.
|
||||
// Looks like the original author is @merykitty.
|
||||
|
||||
int shift = 28 - decimalSepMark;
|
||||
// signed is -1 if negative, 0 otherwise
|
||||
long signed = (~value << 59) >> 63;
|
||||
long designMask = ~(signed & 0xFF);
|
||||
// Align the number to a specific position and transform the ascii code
|
||||
// to actual digit value in each byte
|
||||
long digits = ((value & designMask) << shift) & 0x0F000F0F00L;
|
||||
|
||||
// Now digits is in the form 0xUU00TTHH00 (UU: units digit, TT: tens digit, HH: hundreds digit)
|
||||
// 0xUU00TTHH00 * (100 * 0x1000000 + 10 * 0x10000 + 1) =
|
||||
// 0x000000UU00TTHH00 +
|
||||
// 0x00UU00TTHH000000 * 10 +
|
||||
// 0xUU00TTHH00000000 * 100
|
||||
// Now TT * 100 has 2 trailing zeroes and HH * 100 + TT * 10 + UU < 0x400
|
||||
// This results in our value lies in the bit 32 to 41 of this product
|
||||
// That was close :)
|
||||
long absValue = ((digits * 0x640a0001) >>> 32) & 0x3FF;
|
||||
return (int) ((absValue ^ signed) - signed);
|
||||
}
|
||||
|
||||
private static int nextKeyOffset(int decimalSepMark) {
|
||||
return (decimalSepMark >>> 3) + 3;
|
||||
}
|
||||
|
||||
private void add1(long keyStartAddr, long tailAndLen, int hash, int measurement) {
|
||||
int idx = hash & INDEX_MASK;
|
||||
for (long entryAddr; (entryAddr = UNSAFE.getLong(indexAddr + idx)) != 0; idx = (idx + 8) & INDEX_MASK) {
|
||||
if (update1(entryAddr, tailAndLen, measurement)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
UNSAFE.putLong(indexAddr + idx, create(keyStartAddr, tailAndLen, hash, measurement, '1'));
|
||||
}
|
||||
|
||||
private void add2(long keyStartAddr, long keyLong, long tailAndLen, int hash, int measurement) {
|
||||
int idx = hash & INDEX_MASK;
|
||||
for (long entryAddr; (entryAddr = UNSAFE.getLong(indexAddr + idx)) != 0; idx = (idx + 8) & INDEX_MASK) {
|
||||
if (update2(entryAddr, keyLong, tailAndLen, measurement)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
UNSAFE.putLong(indexAddr + idx, create(keyStartAddr, tailAndLen, hash, measurement, '2'));
|
||||
}
|
||||
|
||||
private void addN(long keyStartAddr, long tailAndLen, int hash, int measurement) {
|
||||
int idx = hash & INDEX_MASK;
|
||||
for (long entryAddr; (entryAddr = UNSAFE.getLong(indexAddr + idx)) != 0; idx = (idx + 8) & INDEX_MASK) {
|
||||
if (updateN(entryAddr, keyStartAddr, tailAndLen, measurement)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
UNSAFE.putLong(indexAddr + idx, create(keyStartAddr, tailAndLen, hash, measurement, 'N'));
|
||||
}
|
||||
|
||||
private long create(long keyStartAddr, long tailAndLen, int hash, int measurement, char _origin) {
|
||||
// assert (memUsed + MAX_STATION_SIZE < memAddr + MAX_STATION_SIZE * MAX_STATIONS) : "Too many stations";
|
||||
|
||||
final long entryAddr = memUsed;
|
||||
|
||||
int keySize = (int) (tailAndLen & 0xF8);
|
||||
long fieldsAddr = entryAddr + HEADER_SIZE + keySize;
|
||||
memUsed += HEADER_SIZE + keySize + FIELDS_SIZE;
|
||||
count++;
|
||||
|
||||
UNSAFE.putLong(entryAddr, tailAndLen);
|
||||
UNSAFE.copyMemory(keyStartAddr, entryAddr + HEADER_SIZE, keySize);
|
||||
UNSAFE.putLong(fieldsAddr + FLD_COUNT, 1);
|
||||
UNSAFE.putLong(fieldsAddr + FLD_SUM, measurement);
|
||||
UNSAFE.putInt(fieldsAddr + FLD_MIN, measurement);
|
||||
UNSAFE.putInt(fieldsAddr + FLD_MAX, measurement);
|
||||
UNSAFE.putInt(fieldsAddr + FLD_HASH, hash);
|
||||
|
||||
return entryAddr;
|
||||
}
|
||||
|
||||
private static boolean update1(long entryAddr, long tailAndLen, int measurement) {
|
||||
if (UNSAFE.getLong(entryAddr) != tailAndLen) {
|
||||
return false;
|
||||
}
|
||||
|
||||
updateStats(entryAddr + HEADER_SIZE, measurement);
|
||||
return true;
|
||||
}
|
||||
|
||||
private static boolean update2(long entryAddr, long keyLong, long tailAndLen, int measurement) {
|
||||
if (UNSAFE.getLong(entryAddr) != tailAndLen) {
|
||||
return false;
|
||||
}
|
||||
if (UNSAFE.getLong(entryAddr + 8) != keyLong) {
|
||||
return false;
|
||||
}
|
||||
|
||||
updateStats(entryAddr + HEADER_SIZE + 8, measurement);
|
||||
return true;
|
||||
}
|
||||
|
||||
private static boolean updateN(long entryAddr, long keyStartAddr, long tailAndLen, int measurement) {
|
||||
if (UNSAFE.getLong(entryAddr) != tailAndLen) {
|
||||
return false;
|
||||
}
|
||||
long memPos = entryAddr + HEADER_SIZE;
|
||||
long memEnd = memPos + ((int) (tailAndLen & 0xF8));
|
||||
long bufPos = keyStartAddr;
|
||||
while (memPos != memEnd) {
|
||||
if (UNSAFE.getLong(memPos) != UNSAFE.getLong(bufPos)) {
|
||||
return false;
|
||||
}
|
||||
memPos += 8;
|
||||
bufPos += 8;
|
||||
}
|
||||
|
||||
updateStats(memPos, measurement);
|
||||
return true;
|
||||
}
|
||||
|
||||
private static void updateStats(long addr, int measurement) {
|
||||
long oldCount = UNSAFE.getLong(addr + FLD_COUNT);
|
||||
long oldSum = UNSAFE.getLong(addr + FLD_SUM);
|
||||
long oldMin = UNSAFE.getInt(addr + FLD_MIN);
|
||||
long oldMax = UNSAFE.getInt(addr + FLD_MAX);
|
||||
|
||||
UNSAFE.putLong(addr + FLD_COUNT, oldCount + 1);
|
||||
UNSAFE.putLong(addr + FLD_SUM, oldSum + measurement);
|
||||
if (measurement < oldMin) {
|
||||
UNSAFE.putInt(addr + FLD_MIN, measurement);
|
||||
}
|
||||
if (measurement > oldMax) {
|
||||
UNSAFE.putInt(addr + FLD_MAX, measurement);
|
||||
}
|
||||
}
|
||||
|
||||
private static void updateStats(long addr, long count, long sum, int min, int max) {
|
||||
long oldCount = UNSAFE.getLong(addr + FLD_COUNT);
|
||||
long oldSum = UNSAFE.getLong(addr + FLD_SUM);
|
||||
long oldMin = UNSAFE.getInt(addr + FLD_MIN);
|
||||
long oldMax = UNSAFE.getInt(addr + FLD_MAX);
|
||||
|
||||
UNSAFE.putLong(addr + FLD_COUNT, oldCount + count);
|
||||
UNSAFE.putLong(addr + FLD_SUM, oldSum + sum);
|
||||
if (min < oldMin) {
|
||||
UNSAFE.putInt(addr + FLD_MIN, min);
|
||||
}
|
||||
if (max > oldMax) {
|
||||
UNSAFE.putInt(addr + FLD_MAX, max);
|
||||
}
|
||||
}
|
||||
|
||||
public Aggregator merge(Aggregator other) {
|
||||
var otherMemPos = other.memAddr;
|
||||
var otherMemEnd = other.memUsed;
|
||||
merge: for (long entrySize; otherMemPos < otherMemEnd; otherMemPos += entrySize) {
|
||||
int keySize = (int) (UNSAFE.getLong(otherMemPos) & 0xF8);
|
||||
long otherKeyEnd = otherMemPos + HEADER_SIZE + keySize;
|
||||
entrySize = HEADER_SIZE + keySize + FIELDS_SIZE;
|
||||
int hash = UNSAFE.getInt(otherKeyEnd + FLD_HASH);
|
||||
int idx = hash & INDEX_MASK;
|
||||
search: for (long entryAddr; (entryAddr = UNSAFE.getLong(indexAddr + idx)) != 0; idx = (idx + 8) & INDEX_MASK) {
|
||||
var thisPos = entryAddr;
|
||||
var otherPos = otherMemPos;
|
||||
while (otherPos < otherKeyEnd) {
|
||||
if (UNSAFE.getLong(thisPos) != UNSAFE.getLong(otherPos)) {
|
||||
continue search;
|
||||
}
|
||||
thisPos += 8;
|
||||
otherPos += 8;
|
||||
}
|
||||
updateStats(
|
||||
thisPos,
|
||||
UNSAFE.getLong(otherPos + FLD_COUNT),
|
||||
UNSAFE.getLong(otherPos + FLD_SUM),
|
||||
UNSAFE.getInt(otherPos + FLD_MIN),
|
||||
UNSAFE.getInt(otherPos + FLD_MAX));
|
||||
continue merge;
|
||||
}
|
||||
|
||||
// create
|
||||
// assert (memUsed + MAX_STATION_SIZE < memAddr + MAX_STATION_SIZE * MAX_STATIONS) : "Too many stations (merge)";
|
||||
long entryAddr = memUsed;
|
||||
memUsed += entrySize;
|
||||
count++;
|
||||
UNSAFE.copyMemory(otherMemPos, entryAddr, entrySize);
|
||||
UNSAFE.putLong(indexAddr + idx, entryAddr);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
if (count == 0) {
|
||||
return "{}";
|
||||
}
|
||||
var entries = new Entry[count];
|
||||
int i = 0;
|
||||
for (long pos = memAddr; pos < memUsed; pos += (int) (UNSAFE.getLong(pos) & 0xF8) + HEADER_SIZE + FIELDS_SIZE) {
|
||||
entries[i++] = new Entry(pos);
|
||||
}
|
||||
Arrays.sort(entries);
|
||||
var sb = new StringBuilder(count * 50);
|
||||
sb.append('{');
|
||||
entries[0].appendTo(sb);
|
||||
for (int j = 1; j < entries.length; ++j) {
|
||||
sb.append(", ");
|
||||
entries[j].appendTo(sb);
|
||||
}
|
||||
sb.append('}');
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
static class Chunk {
|
||||
final MemorySegment file;
|
||||
final long chunkStartAddr;
|
||||
final long chunkEndAddr;
|
||||
final long fileStartAddr;
|
||||
final long fileEndAddr;
|
||||
|
||||
Chunk(MemorySegment file, long chunkStartAddr, long chunkEndAddr, long fileStartAddr, long fileEndAddr) {
|
||||
this.file = file;
|
||||
this.chunkStartAddr = chunkStartAddr;
|
||||
this.chunkEndAddr = chunkEndAddr;
|
||||
this.fileStartAddr = fileStartAddr;
|
||||
this.fileEndAddr = fileEndAddr;
|
||||
}
|
||||
}
|
||||
|
||||
static class Entry implements Comparable<Entry> {
|
||||
private final long entryAddr;
|
||||
private final int keySize;
|
||||
private final String key;
|
||||
|
||||
Entry(long entryAddr) {
|
||||
this.entryAddr = entryAddr;
|
||||
this.keySize = (int) UNSAFE.getLong(entryAddr) & 0xF8;
|
||||
try (var arena = Arena.ofConfined()) {
|
||||
var ms = arena.allocate(keySize + 8);
|
||||
UNSAFE.copyMemory(entryAddr + HEADER_SIZE, ms.address(), keySize);
|
||||
UNSAFE.copyMemory(entryAddr + 1, ms.address() + keySize, 7);
|
||||
this.key = ms.getUtf8String(0);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(Entry other) {
|
||||
return key.compareTo(other.key);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
long pos = entryAddr + HEADER_SIZE + keySize;
|
||||
return round(UNSAFE.getInt(pos + FLD_MIN))
|
||||
+ "/" + round(((double) UNSAFE.getLong(pos + FLD_SUM)) / UNSAFE.getLong(pos + FLD_COUNT))
|
||||
+ "/" + round(UNSAFE.getInt(pos + FLD_MAX));
|
||||
}
|
||||
|
||||
void appendTo(StringBuilder sb) {
|
||||
long pos = entryAddr + HEADER_SIZE + keySize;
|
||||
sb.append(key);
|
||||
sb.append('=');
|
||||
sb.append(round(UNSAFE.getInt(pos + FLD_MIN)));
|
||||
sb.append('/');
|
||||
sb.append(round(((double) UNSAFE.getLong(pos + FLD_SUM)) / UNSAFE.getLong(pos + FLD_COUNT)));
|
||||
sb.append('/');
|
||||
sb.append(round(UNSAFE.getInt(pos + FLD_MAX)));
|
||||
}
|
||||
|
||||
private static double round(double value) {
|
||||
return Math.round(value) / 10.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user