org.apache.pinot.perf.BenchmarkRoaringBitmapCreation Maven / Gradle / Ivy
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.pinot.perf;
import java.io.File;
import java.io.IOException;
import java.lang.ref.SoftReference;
import java.nio.ByteOrder;
import java.util.concurrent.TimeUnit;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.math.RandomUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.pinot.segment.local.segment.creator.impl.inv.BitmapInvertedIndexWriter;
import org.apache.pinot.segment.spi.memory.PinotByteBuffer;
import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.TearDown;
import org.openjdk.jmh.profile.GCProfiler;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.ChainedOptionsBuilder;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.openjdk.jmh.runner.options.TimeValue;
import org.roaringbitmap.RoaringBitmap;
import org.roaringbitmap.buffer.ImmutableRoaringBitmap;
/**
* Benchmark created to test the impact of removing the SoftReference array cache for ImmutableRoaringBitmap
*/
@State(Scope.Benchmark)
@Fork(1)
public class BenchmarkRoaringBitmapCreation {
private static final int NUM_DOCS = 1_000_000;
private static final int CARDINALITY = 100_000;
private static final File TEMP_DIR =
new File(FileUtils.getTempDirectory(), "bitmap_creation_benchmark_" + System.currentTimeMillis());
@Param({"100", "10000", "99999"}) // higher this is, lesser the cache access
public int _dictIdsToRead;
private int _numBitmaps;
private BitmapInvertedIndexWriter _bitmapInvertedIndexWriter;
private SoftReference[]> _bitmapsArrayReference = null;
private SoftReference>[]> _offsetLengthPairsArrayReference = null;
private PinotDataBuffer _offsetLengthBuffer;
private PinotDataBuffer _bitmapBuffer;
private int _firstOffset;
@Setup
public void setup()
throws IllegalAccessException, InstantiationException, IOException {
_numBitmaps = CARDINALITY;
File bufferDir = new File(TEMP_DIR, "cardinality_" + CARDINALITY);
FileUtils.forceMkdir(bufferDir);
File bufferFile = new File(bufferDir, "buffer");
_bitmapInvertedIndexWriter = new BitmapInvertedIndexWriter(bufferFile, _numBitmaps);
// Insert between 10-1000 values per bitmap
for (int i = 0; i < _numBitmaps; i++) {
int size = 10 + RandomUtils.nextInt(990);
int[] data = new int[size];
for (int j = 0; j < size; j++) {
data[j] = RandomUtils
.nextInt(NUM_DOCS); // docIds will repeat across bitmaps, but doesn't matter for purpose of this benchmark
}
RoaringBitmap bitmap = RoaringBitmap.bitmapOf(data);
_bitmapInvertedIndexWriter.add(bitmap);
}
PinotDataBuffer dataBuffer = PinotByteBuffer.mapReadOnlyBigEndianFile(bufferFile);
long offsetBufferEndOffset = (long) (_numBitmaps + 1) * Integer.BYTES;
_offsetLengthBuffer = dataBuffer.view(0, offsetBufferEndOffset, ByteOrder.BIG_ENDIAN);
_bitmapBuffer = dataBuffer.view(offsetBufferEndOffset, dataBuffer.size());
_firstOffset = _offsetLengthBuffer.getInt(0);
}
@TearDown
public void teardown()
throws IOException {
_bitmapInvertedIndexWriter.close();
FileUtils.deleteQuietly(TEMP_DIR);
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public boolean cacheReferences() {
int dictId = RandomUtils.nextInt(_dictIdsToRead);
ImmutableRoaringBitmap roaringBitmapFromCache = getRoaringBitmapFromCache(dictId);
return roaringBitmapFromCache.isEmpty();
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public boolean alwaysBuild() {
int dictId = RandomUtils.nextInt(_dictIdsToRead);
ImmutableRoaringBitmap immutableRoaringBitmap = buildRoaringBitmap(dictId);
return immutableRoaringBitmap.isEmpty();
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public boolean alwaysBuildCachedOffsetAndLength() {
int dictId = RandomUtils.nextInt(_dictIdsToRead);
ImmutableRoaringBitmap immutableRoaringBitmap = buildRoaringBitmapUsingOffsetPairFromCache(dictId);
return immutableRoaringBitmap.isEmpty();
}
/**
* Code as of before this commit, using an array of SoftReference for the ImmutableRoaringBitmap
*/
private ImmutableRoaringBitmap getRoaringBitmapFromCache(int dictId) {
SoftReference[] bitmapArrayReference =
(_bitmapsArrayReference != null) ? _bitmapsArrayReference.get() : null;
if (bitmapArrayReference != null) {
SoftReference bitmapReference = bitmapArrayReference[dictId];
ImmutableRoaringBitmap bitmap = (bitmapReference != null) ? bitmapReference.get() : null;
if (bitmap != null) {
return bitmap;
}
} else {
bitmapArrayReference = new SoftReference[_numBitmaps];
_bitmapsArrayReference = new SoftReference<>(bitmapArrayReference);
}
synchronized (this) {
SoftReference bitmapReference = bitmapArrayReference[dictId];
ImmutableRoaringBitmap bitmap = (bitmapReference != null) ? bitmapReference.get() : null;
if (bitmap == null) {
bitmap = buildRoaringBitmap(dictId);
bitmapArrayReference[dictId] = new SoftReference<>(bitmap);
}
return bitmap;
}
}
private ImmutableRoaringBitmap buildRoaringBitmap(int dictId) {
Pair offsetLengthPair = buildOffsetLengthPair(dictId);
return buildRoaringBitmap(offsetLengthPair);
}
private Pair buildOffsetLengthPair(int dictId) {
int offset = _offsetLengthBuffer.getInt(dictId * Integer.BYTES);
int length = _offsetLengthBuffer.getInt((dictId + 1) * Integer.BYTES) - offset;
return Pair.of(offset, length);
}
private ImmutableRoaringBitmap buildRoaringBitmap(Pair offsetLengthPair) {
return new ImmutableRoaringBitmap(
_bitmapBuffer.toDirectByteBuffer(offsetLengthPair.getLeft() - _firstOffset, offsetLengthPair.getRight()));
}
private ImmutableRoaringBitmap buildRoaringBitmapUsingOffsetPairFromCache(int dictId) {
return buildRoaringBitmap(getOffsetLengthPairFromCache(dictId));
}
private Pair getOffsetLengthPairFromCache(int dictId) {
SoftReference>[] offsetLengthPairArrayReference =
(_offsetLengthPairsArrayReference != null) ? _offsetLengthPairsArrayReference.get() : null;
if (offsetLengthPairArrayReference != null) {
SoftReference> offsetLengthPairReference = offsetLengthPairArrayReference[dictId];
Pair offsetLengthPair =
(offsetLengthPairReference != null) ? offsetLengthPairReference.get() : null;
if (offsetLengthPair != null) {
return offsetLengthPair;
}
} else {
offsetLengthPairArrayReference = new SoftReference[_numBitmaps];
_offsetLengthPairsArrayReference = new SoftReference<>(offsetLengthPairArrayReference);
}
synchronized (this) {
SoftReference> offsetLengthPairReference = offsetLengthPairArrayReference[dictId];
Pair offsetLengthPair =
(offsetLengthPairReference != null) ? offsetLengthPairReference.get() : null;
if (offsetLengthPair == null) {
offsetLengthPair = buildOffsetLengthPair(dictId);
offsetLengthPairArrayReference[dictId] = new SoftReference<>(offsetLengthPair);
}
return offsetLengthPair;
}
}
public static void main(String[] args)
throws Exception {
ChainedOptionsBuilder opt = new OptionsBuilder().include(BenchmarkRoaringBitmapCreation.class.getSimpleName())
.warmupTime(TimeValue.seconds(10)).warmupIterations(1).measurementTime(TimeValue.seconds(60))
.measurementIterations(1).forks(1).addProfiler(GCProfiler.class);
new Runner(opt.build()).run();
}
}