2024-01-03 10:14:19 +01:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
import java.io.*;
|
|
|
|
import java.nio.CharBuffer;
|
|
|
|
import java.nio.charset.StandardCharsets;
|
2024-01-03 10:14:19 +01:00
|
|
|
import java.nio.file.Files;
|
|
|
|
import java.nio.file.Path;
|
|
|
|
import java.time.Duration;
|
|
|
|
import java.time.Instant;
|
2024-01-03 14:53:38 +01:00
|
|
|
import java.util.Map;
|
2024-01-03 10:14:19 +01:00
|
|
|
import java.util.TreeMap;
|
|
|
|
|
|
|
|
// gunnar morling - 2:10
|
|
|
|
// roy van rijn - 1:01
|
2024-01-03 14:53:38 +01:00
|
|
|
// 0:37
|
2024-01-03 10:14:19 +01:00
|
|
|
|
|
|
|
public class CalculateAverage_ddimtirov {
|
|
|
|
|
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
@SuppressWarnings("RedundantSuppression")
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
|
// var start = Instant.now();
|
|
|
|
Instant start = null;
|
|
|
|
var path = Path.of("./measurements.txt");
|
|
|
|
var bufferSize = 512 * 64; // 64 blocks
|
|
|
|
var tracker = new Tracker();
|
|
|
|
var charset = StandardCharsets.UTF_8;
|
|
|
|
|
|
|
|
// Files.lines() is optimized for files that can be indexed by int
|
|
|
|
// For larger files it falls back to buffered reader, which we now
|
|
|
|
// use directly to be able to tweak the buffer size.
|
|
|
|
try (var stream = Files.newInputStream(path); var reader = new InputStreamReader(stream, charset)) {
|
|
|
|
var buffered = new RecordReader(reader, bufferSize);
|
2024-01-03 10:14:19 +01:00
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
InputRecord record = null;
|
|
|
|
while (true) {
|
|
|
|
record = buffered.readRecord(record);
|
|
|
|
if (record==null) break;
|
|
|
|
|
|
|
|
tracker.process(record);
|
2024-01-03 10:14:19 +01:00
|
|
|
}
|
2024-01-03 14:53:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
System.out.println(tracker.stationsToMetrics());
|
|
|
|
|
|
|
|
//noinspection ConstantValue
|
|
|
|
if (start!=null) System.err.println(Duration.between(start, Instant.now()));
|
|
|
|
|
|
|
|
assert Files.readAllLines(Path.of("expected_result.txt")).getFirst().equals(tracker.stationsToMetrics().toString());
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Reads records we can use to do the filtering from a stream of characters.
|
|
|
|
* Takes care of framing, and I/O buffering.
|
|
|
|
* This class in combination with {@link RecordReader} allows us to fully hide the
|
|
|
|
* I/O and internal representation.
|
|
|
|
*
|
|
|
|
* <p>If used with recycled {@link InputRecord} instances, this class allocates no memory
|
|
|
|
* after instantiation. The class is stateful, and the internals are not threadsafe
|
|
|
|
* - use from single thread or with proper synchronization.
|
|
|
|
*/
|
|
|
|
static class RecordReader {
|
|
|
|
/**
|
|
|
|
* The source of input data
|
|
|
|
*/
|
|
|
|
private final Readable input;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Used for i/o buffering and record parsing.
|
|
|
|
* @see #buf
|
|
|
|
*/
|
|
|
|
private final CharBuffer buffer;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* <p>Cached backing array from {@link #buffer}.
|
|
|
|
* <p>This is optimization because {@link CharBuffer#array()} was showing on the CPU profile.
|
|
|
|
*/
|
|
|
|
private final char[] buf;
|
|
|
|
|
|
|
|
public RecordReader(Readable input, int bufferSize) {
|
|
|
|
this.input = input;
|
|
|
|
buffer = CharBuffer.allocate(bufferSize).flip();
|
|
|
|
buf = buffer.array();
|
|
|
|
}
|
|
|
|
|
|
|
|
public InputRecord readRecord(InputRecord recycled) throws IOException {
|
|
|
|
var record = parseRecord(recycled);
|
|
|
|
if (record!=null) return record;
|
2024-01-03 10:14:19 +01:00
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
if (input.read(buffer.compact())==-1) return null;
|
|
|
|
buffer.flip();
|
2024-01-03 10:14:19 +01:00
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
return parseRecord(recycled);
|
2024-01-03 10:14:19 +01:00
|
|
|
}
|
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
|
|
|
|
private InputRecord parseRecord(InputRecord recycled) {
|
|
|
|
var lim = buffer.limit();
|
|
|
|
if (buffer.isEmpty()) return null;
|
|
|
|
|
|
|
|
var nameOff = buffer.position();
|
|
|
|
var buff = buf;
|
|
|
|
while (buff[nameOff]=='\n' || buff[nameOff]=='\r' || buff[nameOff]==' ' ) {
|
|
|
|
nameOff++;
|
|
|
|
if (nameOff>=lim) return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
var nameHash = 0;
|
|
|
|
var nameLen = 0;
|
|
|
|
while (buff[nameOff+nameLen]!=';') {
|
|
|
|
nameHash = nameHash*31 + buff[nameOff+nameLen];
|
|
|
|
nameLen++;
|
|
|
|
if (nameOff+nameLen>=lim) return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
//noinspection DuplicateExpressions
|
|
|
|
assert new String(buf, nameOff, nameLen).hashCode()==nameHash
|
|
|
|
: "'%s'@%d !-> %d".formatted(new String(buf, nameOff, nameLen), new String(buf, nameOff, nameLen).hashCode(), nameHash);
|
|
|
|
|
|
|
|
var valCursor = nameOff + nameLen +1;
|
|
|
|
int signum = 1;
|
|
|
|
var acc = 0;
|
|
|
|
while (true) {
|
|
|
|
if (valCursor >= lim) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
char c = buff[valCursor++];
|
|
|
|
if (c == '\n' || c == '\r') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (c=='.') continue;
|
|
|
|
if (acc == 0) {
|
|
|
|
if (c == '-') {
|
|
|
|
signum = -1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
acc *= 10;
|
|
|
|
}
|
2024-01-03 10:14:19 +01:00
|
|
|
var v = c - '0';
|
|
|
|
assert v>=0 && v<=9 : String.format("Character '%s', value %,d", c, v);
|
|
|
|
acc += v;
|
|
|
|
}
|
2024-01-03 14:53:38 +01:00
|
|
|
|
|
|
|
buffer.position(valCursor);
|
|
|
|
|
|
|
|
var record = recycled!=null ? recycled : new InputRecord(buf);
|
|
|
|
record.init(nameHash, nameOff, nameLen, acc*signum);
|
|
|
|
return record;
|
2024-01-03 10:14:19 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
static class Tracker {
|
|
|
|
private static final int ADDRESS_NO_CLASH_MODULUS = 49999;
|
|
|
|
private static final int OFFSET_MIN = 0;
|
|
|
|
private static final int OFFSET_MAX = 1;
|
|
|
|
private static final int OFFSET_COUNT = 2;
|
|
|
|
|
|
|
|
private final int[] minMaxCount = new int[ADDRESS_NO_CLASH_MODULUS * 3];
|
|
|
|
private final long[] sums = new long[ADDRESS_NO_CLASH_MODULUS];
|
|
|
|
private final String[] names = new String[ADDRESS_NO_CLASH_MODULUS];
|
|
|
|
|
|
|
|
public void process(InputRecord r) {
|
|
|
|
var i = Math.abs(r.nameHash) % ADDRESS_NO_CLASH_MODULUS;
|
|
|
|
|
|
|
|
if (names[i]==null) names[i] = r.name();
|
|
|
|
|
|
|
|
sums[i] += r.value;
|
|
|
|
|
|
|
|
int mmcIndex = i * 3;
|
|
|
|
var min = minMaxCount[mmcIndex + OFFSET_MIN];
|
|
|
|
var max = minMaxCount[mmcIndex + OFFSET_MAX];
|
|
|
|
if (r.value < min) minMaxCount[mmcIndex + OFFSET_MIN] = r.value;
|
|
|
|
if (r.value > max) minMaxCount[mmcIndex + OFFSET_MAX] = r.value;
|
|
|
|
|
|
|
|
minMaxCount[mmcIndex + OFFSET_COUNT]++;
|
2024-01-03 10:14:19 +01:00
|
|
|
}
|
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
|
|
|
|
|
|
|
|
public Map<String, String> stationsToMetrics() {
|
|
|
|
var m = new TreeMap<String, String>();
|
|
|
|
for (int i = 0; i < names.length; i++) {
|
|
|
|
var name = names[i];
|
|
|
|
if (name==null) continue;
|
|
|
|
|
|
|
|
var min = minMaxCount[i*3] / 10.0;
|
|
|
|
var max = minMaxCount[i*3+1] / 10.0;
|
|
|
|
var count = minMaxCount[i*3+2];
|
|
|
|
var sum = sums[i];
|
|
|
|
var mean = Math.round((double) sum / count) / 10.0;
|
|
|
|
|
|
|
|
m.put(name, min + "/" + mean + "/" + max);
|
|
|
|
}
|
|
|
|
return m;
|
2024-01-03 10:14:19 +01:00
|
|
|
}
|
2024-01-03 14:53:38 +01:00
|
|
|
|
2024-01-03 10:14:19 +01:00
|
|
|
}
|
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
static class InputRecord {
|
|
|
|
private final char[] chars;
|
|
|
|
private int idOffset;
|
|
|
|
private int idLength;
|
2024-01-03 10:14:19 +01:00
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
public int value; // fixpoint scaled by 10
|
|
|
|
public int nameHash;
|
|
|
|
|
|
|
|
public InputRecord(char[] chars) {
|
|
|
|
this.chars = chars;
|
2024-01-03 10:14:19 +01:00
|
|
|
}
|
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
public void init(int nameHash, int nameOffset, int nameLength, int fixpointValue) {
|
|
|
|
assert nameOffset+nameLength<chars.length : String.format("idOffset+idLength=%d < chars.length=%d", nameOffset+nameLength, chars.length);
|
2024-01-03 10:14:19 +01:00
|
|
|
|
2024-01-03 14:53:38 +01:00
|
|
|
this.idOffset = nameOffset;
|
|
|
|
this.idLength = nameLength;
|
|
|
|
this.value = fixpointValue;
|
|
|
|
this.nameHash = nameHash;
|
|
|
|
}
|
|
|
|
|
|
|
|
public String name() {
|
|
|
|
return new String(chars, idOffset, idLength);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String toString() {
|
|
|
|
return name() + ";" + (value / 10.0);
|
|
|
|
}
|
|
|
|
}
|
2024-01-03 10:14:19 +01:00
|
|
|
}
|