/**
* This code is released under the
* Apache License Version 2.0 http://www.apache.org/licenses/.
*/
package me.lemire.integercompression.benchmarktools;
import java.io.File;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Random;
import me.lemire.integercompression.BinaryPacking;
import me.lemire.integercompression.DeltaZigzagBinaryPacking;
import me.lemire.integercompression.DeltaZigzagVariableByte;
import me.lemire.integercompression.FastPFOR;
import me.lemire.integercompression.FastPFOR128;
import me.lemire.integercompression.IntWrapper;
import me.lemire.integercompression.IntegerCODEC;
import me.lemire.integercompression.JustCopy;
import me.lemire.integercompression.differential.IntegratedBinaryPacking;
import me.lemire.integercompression.differential.XorBinaryPacking;
/**
* Simple synthetic benchmark
*
*/
public class BenchmarkOffsettedSeries {
private static final int DEFAULT_MEAN = 1 << 20;
private static final int DEFAULT_RANGE = 1 << 10;
private static final int DEFAULT_REPEAT = 5;
private static final int DEFAULT_WARMUP = 2;
/**
* Run benchmark.
*
* @param csvWriter
* Write for results in CSV.
* @param count
* Count of data chunks.
* @param length
* Length of a data chunk.
*/
public static void run(final PrintWriter csvWriter, final int count, final int length) {
IntegerCODEC[] codecs = { new JustCopy(), new BinaryPacking(),
new DeltaZigzagBinaryPacking(),
new DeltaZigzagVariableByte(),
new IntegratedBinaryPacking(), new XorBinaryPacking(),
new FastPFOR128(), new FastPFOR()};
csvWriter
.format("\"Dataset\",\"CODEC\",\"Bits per int\","
+ "\"Compress speed (MiS)\",\"Decompress speed (MiS)\"\n");
benchmark(csvWriter, codecs, count, length, DEFAULT_MEAN,
DEFAULT_RANGE);
benchmark(csvWriter, codecs, count, length, DEFAULT_MEAN >> 5,
DEFAULT_RANGE);
IntegerCODEC[] codecs2 = { new JustCopy(), new BinaryPacking(),
new DeltaZigzagBinaryPacking(),
new DeltaZigzagVariableByte(),
new IntegratedBinaryPacking(), new XorBinaryPacking(),
new FastPFOR128(),new FastPFOR(), };
int freq = length / 4;
benchmarkSine(csvWriter, codecs2, count, length,
DEFAULT_MEAN >> 0, DEFAULT_RANGE >> 0, freq);
benchmarkSine(csvWriter, codecs2, count, length,
DEFAULT_MEAN >> 5, DEFAULT_RANGE >> 0, freq);
benchmarkSine(csvWriter, codecs2, count, length,
DEFAULT_MEAN >> 10, DEFAULT_RANGE >> 0, freq);
benchmarkSine(csvWriter, codecs2, count, length,
DEFAULT_MEAN >> 0, DEFAULT_RANGE >> 2, freq);
benchmarkSine(csvWriter, codecs2, count, length,
DEFAULT_MEAN >> 5, DEFAULT_RANGE >> 2, freq);
benchmarkSine(csvWriter, codecs2, count, length,
DEFAULT_MEAN >> 10, DEFAULT_RANGE >> 2, freq);
benchmarkSine(csvWriter, codecs2, count, length,
DEFAULT_MEAN >> 0, DEFAULT_RANGE >> 4, freq);
benchmarkSine(csvWriter, codecs2, count, length,
DEFAULT_MEAN >> 5, DEFAULT_RANGE >> 4, freq);
benchmarkSine(csvWriter, codecs2, count, length,
DEFAULT_MEAN >> 10, DEFAULT_RANGE >> 4, freq);
}
private static void benchmarkSine(final PrintWriter csvWriter,
final IntegerCODEC[] codecs, final int count, final int length, final int mean,
final int range, final int freq) {
String dataProp = String.format(
"(mean=%1$d range=%2$d freq=%3$d)", mean, range, freq);
int[][] data = generateSineDataChunks(0, count, length, mean,
range, freq);
benchmark(csvWriter, "Sine " + dataProp, codecs, data,
DEFAULT_REPEAT, DEFAULT_WARMUP);
benchmark(csvWriter, "Sine+delta " + dataProp, codecs, data,
DEFAULT_REPEAT, DEFAULT_WARMUP);
}
private static void benchmark(final PrintWriter csvWriter, final IntegerCODEC[] codecs,
final int count, final int length, final int mean, final int range) {
String dataProp = String.format("(mean=%1$d range=%2$d)", mean,
range);
int[][] randData = generateDataChunks(0, count, length, mean,
range);
int[][] deltaData = deltaDataChunks(randData);
int[][] sortedData = sortDataChunks(randData);
int[][] sortedDeltaData = deltaDataChunks(sortedData);
benchmark(csvWriter, "Random " + dataProp, codecs, randData,
DEFAULT_REPEAT, DEFAULT_WARMUP);
benchmark(csvWriter, "Random+delta " + dataProp, codecs,
deltaData, DEFAULT_REPEAT, DEFAULT_WARMUP);
benchmark(csvWriter, "Sorted " + dataProp, codecs, sortedData,
DEFAULT_REPEAT, DEFAULT_WARMUP);
benchmark(csvWriter, "Sorted+delta " + dataProp, codecs,
sortedDeltaData, DEFAULT_REPEAT, DEFAULT_WARMUP);
}
private static void benchmark(final PrintWriter csvWriter, final String dataName,
final IntegerCODEC[] codecs, final int[][] data, final int repeat, final int warmup) {
System.out.println("Processing: " + dataName);
for (IntegerCODEC codec : codecs) {
String codecName = codec.toString();
for (int i = 0; i < warmup; ++i) {
benchmark(null, null, null, codec, data, repeat);
}
benchmark(csvWriter, dataName, codecName, codec, data,
repeat);
}
}
private static void benchmark(PrintWriter csvWriter, String dataName,
String codecName, IntegerCODEC codec, int[][] data, int repeat) {
PerformanceLogger logger = new PerformanceLogger();
int maxLen = getMaxLen(data);
int[] compressBuffer = new int[4 * maxLen + 1024];
int[] decompressBuffer = new int[maxLen];
for (int i = 0; i < repeat; ++i) {
for (int[] array : data) {
int compSize = compress(logger, codec, array,
compressBuffer);
int decompSize = decompress(logger, codec,
compressBuffer, compSize,
decompressBuffer);
checkArray(array, decompressBuffer, decompSize,
codec);
}
}
if (csvWriter != null) {
csvWriter.format(
"\"%1$s\",\"%2$s\",%3$.2f,%4$.0f,%5$.0f\n",
dataName, codecName, logger.getBitPerInt(),
logger.getCompressSpeed(),
logger.getDecompressSpeed());
}
}
private static void checkArray(int[] expected, int[] actualArray,
int actualLen, IntegerCODEC codec) {
if (actualLen != expected.length) {
throw new RuntimeException("Length mismatch:"
+ " expected=" + expected.length + " actual="
+ actualLen + " codec=" + codec.toString());
}
for (int i = 0; i < expected.length; ++i) {
if (actualArray[i] != expected[i]) {
throw new RuntimeException("Value mismatch: "
+ " where=" + i + " expected="
+ expected[i] + " actual="
+ actualArray[i] + " codec="
+ codec.toString());
}
}
}
private static int compress(PerformanceLogger logger, IntegerCODEC codec,
int[] src, int[] dst) {
IntWrapper inpos = new IntWrapper();
IntWrapper outpos = new IntWrapper();
logger.compressionTimer.start();
codec.compress(src, inpos, src.length, dst, outpos);
logger.compressionTimer.end();
int outSize = outpos.get();
logger.addOriginalSize(src.length);
logger.addCompressedSize(outSize);
return outSize;
}
private static int decompress(PerformanceLogger logger, IntegerCODEC codec,
int[] src, int srcLen, int[] dst) {
IntWrapper inpos = new IntWrapper();
IntWrapper outpos = new IntWrapper();
logger.decompressionTimer.start();
codec.uncompress(src, inpos, srcLen, dst, outpos);
logger.decompressionTimer.end();
return outpos.get();
}
private static int getMaxLen(int[][] data) {
int maxLen = 0;
for (int[] array : data) {
if (array.length > maxLen) {
maxLen = array.length;
}
}
return maxLen;
}
private static int[][] generateSineDataChunks(long seed, int count,
int length, int mean, int range, int freq) {
int[][] chunks = new int[count][];
Random r = new Random(seed);
for (int i = 0; i < count; ++i) {
int[] chunk = chunks[i] = new int[length];
int phase = r.nextInt(2 * freq);
for (int j = 0; j < length; ++j) {
double angle = 2.0 * Math.PI * (j + phase)
/ freq;
chunk[j] = (int) (mean + Math.sin(angle)
* range);
}
}
return chunks;
}
private static int[][] generateDataChunks(long seed, int count,
int length, int mean, int range) {
int offset = mean - range / 2;
int[][] chunks = new int[count][];
Random r = new Random(seed);
for (int i = 0; i < count; ++i) {
int[] chunk = chunks[i] = new int[length];
for (int j = 0; j < length; ++j) {
chunk[j] = r.nextInt(range) + offset;
}
}
return chunks;
}
private static int[][] deltaDataChunks(int[][] src) {
int[][] dst = new int[src.length][];
for (int i = 0; i < src.length; ++i) {
int[] s = src[i];
int[] d = dst[i] = new int[s.length];
int prev = 0;
for (int j = 0; j < s.length; ++j) {
d[j] = s[j] - prev;
prev = s[j];
}
}
return dst;
}
private static int[][] sortDataChunks(int[][] src) {
int[][] dst = new int[src.length][];
for (int i = 0; i < src.length; ++i) {
dst[i] = Arrays.copyOf(src[i], src[i].length);
Arrays.sort(dst[i]);
}
return dst;
}
/**
* @param args command-line arguments
* @throws Exception when some problem occurs
*/
public static void main(final String[] args) throws Exception {
File csvFile = new File(
String.format(
"benchmark-offsetted-%1$tY%1$tm%1$tdT%1$tH%1$tM%1$tS.csv",
System.currentTimeMillis()));
PrintWriter writer = null;
try {
writer = new PrintWriter(csvFile);
System.out
.println("# Results will be written into a CSV file: "
+ csvFile.getName());
System.out.println();
BenchmarkOffsettedSeries.run(writer, 8 * 1024, 1280);
System.out.println();
System.out
.println("# Results were written into a CSV file: "
+ csvFile.getName());
} finally {
if (writer != null) {
writer.close();
}
}
}
}