393 lines
9.3 KiB
Java
393 lines
9.3 KiB
Java
package SevenZip;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.IOException;
|
|
|
|
public class LzmaBench
|
|
{
|
|
static final int kAdditionalSize = (1 << 21);
|
|
static final int kCompressedAdditionalSize = (1 << 10);
|
|
|
|
static class CRandomGenerator
|
|
{
|
|
int A1;
|
|
int A2;
|
|
public CRandomGenerator() { Init(); }
|
|
public void Init() { A1 = 362436069; A2 = 521288629; }
|
|
public int GetRnd()
|
|
{
|
|
return
|
|
((A1 = 36969 * (A1 & 0xffff) + (A1 >>> 16)) << 16) ^
|
|
((A2 = 18000 * (A2 & 0xffff) + (A2 >>> 16)));
|
|
}
|
|
};
|
|
|
|
static class CBitRandomGenerator
|
|
{
|
|
CRandomGenerator RG = new CRandomGenerator();
|
|
int Value;
|
|
int NumBits;
|
|
public void Init()
|
|
{
|
|
Value = 0;
|
|
NumBits = 0;
|
|
}
|
|
public int GetRnd(int numBits)
|
|
{
|
|
int result;
|
|
if (NumBits > numBits)
|
|
{
|
|
result = Value & ((1 << numBits) - 1);
|
|
Value >>>= numBits;
|
|
NumBits -= numBits;
|
|
return result;
|
|
}
|
|
numBits -= NumBits;
|
|
result = (Value << numBits);
|
|
Value = RG.GetRnd();
|
|
result |= Value & (((int)1 << numBits) - 1);
|
|
Value >>>= numBits;
|
|
NumBits = 32 - numBits;
|
|
return result;
|
|
}
|
|
};
|
|
|
|
static class CBenchRandomGenerator
|
|
{
|
|
CBitRandomGenerator RG = new CBitRandomGenerator();
|
|
int Pos;
|
|
int Rep0;
|
|
|
|
public int BufferSize;
|
|
public byte[] Buffer = null;
|
|
|
|
public CBenchRandomGenerator() { }
|
|
public void Set(int bufferSize)
|
|
{
|
|
Buffer = new byte[bufferSize];
|
|
Pos = 0;
|
|
BufferSize = bufferSize;
|
|
}
|
|
int GetRndBit() { return RG.GetRnd(1); }
|
|
int GetLogRandBits(int numBits)
|
|
{
|
|
int len = RG.GetRnd(numBits);
|
|
return RG.GetRnd((int)len);
|
|
}
|
|
int GetOffset()
|
|
{
|
|
if (GetRndBit() == 0)
|
|
return GetLogRandBits(4);
|
|
return (GetLogRandBits(4) << 10) | RG.GetRnd(10);
|
|
}
|
|
int GetLen1() { return RG.GetRnd(1 + (int)RG.GetRnd(2)); }
|
|
int GetLen2() { return RG.GetRnd(2 + (int)RG.GetRnd(2)); }
|
|
public void Generate()
|
|
{
|
|
RG.Init();
|
|
Rep0 = 1;
|
|
while (Pos < BufferSize)
|
|
{
|
|
if (GetRndBit() == 0 || Pos < 1)
|
|
Buffer[Pos++] = (byte)(RG.GetRnd(8));
|
|
else
|
|
{
|
|
int len;
|
|
if (RG.GetRnd(3) == 0)
|
|
len = 1 + GetLen1();
|
|
else
|
|
{
|
|
do
|
|
Rep0 = GetOffset();
|
|
while (Rep0 >= Pos);
|
|
Rep0++;
|
|
len = 2 + GetLen2();
|
|
}
|
|
for (int i = 0; i < len && Pos < BufferSize; i++, Pos++)
|
|
Buffer[Pos] = Buffer[Pos - Rep0];
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
static class CrcOutStream extends java.io.OutputStream
|
|
{
|
|
public CRC CRC = new CRC();
|
|
|
|
public void Init()
|
|
{
|
|
CRC.Init();
|
|
}
|
|
public int GetDigest()
|
|
{
|
|
return CRC.GetDigest();
|
|
}
|
|
public void write(byte[] b)
|
|
{
|
|
CRC.Update(b);
|
|
}
|
|
public void write(byte[] b, int off, int len)
|
|
{
|
|
CRC.Update(b, off, len);
|
|
}
|
|
public void write(int b)
|
|
{
|
|
CRC.UpdateByte(b);
|
|
}
|
|
};
|
|
|
|
static class MyOutputStream extends java.io.OutputStream
|
|
{
|
|
byte[] _buffer;
|
|
int _size;
|
|
int _pos;
|
|
|
|
public MyOutputStream(byte[] buffer)
|
|
{
|
|
_buffer = buffer;
|
|
_size = _buffer.length;
|
|
}
|
|
|
|
public void reset()
|
|
{
|
|
_pos = 0;
|
|
}
|
|
|
|
public void write(int b) throws IOException
|
|
{
|
|
if (_pos >= _size)
|
|
throw new IOException("Error");
|
|
_buffer[_pos++] = (byte)b;
|
|
}
|
|
|
|
public int size()
|
|
{
|
|
return _pos;
|
|
}
|
|
};
|
|
|
|
static class MyInputStream extends java.io.InputStream
|
|
{
|
|
byte[] _buffer;
|
|
int _size;
|
|
int _pos;
|
|
|
|
public MyInputStream(byte[] buffer, int size)
|
|
{
|
|
_buffer = buffer;
|
|
_size = size;
|
|
}
|
|
|
|
public void reset()
|
|
{
|
|
_pos = 0;
|
|
}
|
|
|
|
public int read()
|
|
{
|
|
if (_pos >= _size)
|
|
return -1;
|
|
return _buffer[_pos++] & 0xFF;
|
|
}
|
|
};
|
|
|
|
static class CProgressInfo implements ICodeProgress
|
|
{
|
|
public long ApprovedStart;
|
|
public long InSize;
|
|
public long Time;
|
|
public void Init()
|
|
{ InSize = 0; }
|
|
public void SetProgress(long inSize, long outSize)
|
|
{
|
|
if (inSize >= ApprovedStart && InSize == 0)
|
|
{
|
|
Time = System.currentTimeMillis();
|
|
InSize = inSize;
|
|
}
|
|
}
|
|
}
|
|
static final int kSubBits = 8;
|
|
|
|
static int GetLogSize(int size)
|
|
{
|
|
for (int i = kSubBits; i < 32; i++)
|
|
for (int j = 0; j < (1 << kSubBits); j++)
|
|
if (size <= ((1) << i) + (j << (i - kSubBits)))
|
|
return (i << kSubBits) + j;
|
|
return (32 << kSubBits);
|
|
}
|
|
|
|
static long MyMultDiv64(long value, long elapsedTime)
|
|
{
|
|
long freq = 1000; // ms
|
|
long elTime = elapsedTime;
|
|
while (freq > 1000000)
|
|
{
|
|
freq >>>= 1;
|
|
elTime >>>= 1;
|
|
}
|
|
if (elTime == 0)
|
|
elTime = 1;
|
|
return value * freq / elTime;
|
|
}
|
|
|
|
static long GetCompressRating(int dictionarySize, long elapsedTime, long size)
|
|
{
|
|
long t = GetLogSize(dictionarySize) - (18 << kSubBits);
|
|
long numCommandsForOne = 1060 + ((t * t * 10) >> (2 * kSubBits));
|
|
long numCommands = (long)(size) * numCommandsForOne;
|
|
return MyMultDiv64(numCommands, elapsedTime);
|
|
}
|
|
|
|
static long GetDecompressRating(long elapsedTime, long outSize, long inSize)
|
|
{
|
|
long numCommands = inSize * 220 + outSize * 20;
|
|
return MyMultDiv64(numCommands, elapsedTime);
|
|
}
|
|
|
|
static long GetTotalRating(
|
|
int dictionarySize,
|
|
long elapsedTimeEn, long sizeEn,
|
|
long elapsedTimeDe,
|
|
long inSizeDe, long outSizeDe)
|
|
{
|
|
return (GetCompressRating(dictionarySize, elapsedTimeEn, sizeEn) +
|
|
GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;
|
|
}
|
|
|
|
static void PrintValue(long v)
|
|
{
|
|
String s = "";
|
|
s += v;
|
|
for (int i = 0; i + s.length() < 6; i++)
|
|
System.out.print(" ");
|
|
System.out.print(s);
|
|
}
|
|
|
|
static void PrintRating(long rating)
|
|
{
|
|
PrintValue(rating / 1000000);
|
|
System.out.print(" MIPS");
|
|
}
|
|
|
|
static void PrintResults(
|
|
int dictionarySize,
|
|
long elapsedTime,
|
|
long size,
|
|
boolean decompressMode, long secondSize)
|
|
{
|
|
long speed = MyMultDiv64(size, elapsedTime);
|
|
PrintValue(speed / 1024);
|
|
System.out.print(" KB/s ");
|
|
long rating;
|
|
if (decompressMode)
|
|
rating = GetDecompressRating(elapsedTime, size, secondSize);
|
|
else
|
|
rating = GetCompressRating(dictionarySize, elapsedTime, size);
|
|
PrintRating(rating);
|
|
}
|
|
|
|
static public int LzmaBenchmark(int numIterations, int dictionarySize) throws Exception
|
|
{
|
|
if (numIterations <= 0)
|
|
return 0;
|
|
if (dictionarySize < (1 << 18))
|
|
{
|
|
System.out.println("\nError: dictionary size for benchmark must be >= 18 (256 KB)");
|
|
return 1;
|
|
}
|
|
System.out.print("\n Compressing Decompressing\n\n");
|
|
|
|
SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
|
|
SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder();
|
|
|
|
if (!encoder.SetDictionarySize(dictionarySize))
|
|
throw new Exception("Incorrect dictionary size");
|
|
|
|
int kBufferSize = dictionarySize + kAdditionalSize;
|
|
int kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;
|
|
|
|
ByteArrayOutputStream propStream = new ByteArrayOutputStream();
|
|
encoder.WriteCoderProperties(propStream);
|
|
byte[] propArray = propStream.toByteArray();
|
|
decoder.SetDecoderProperties(propArray);
|
|
|
|
CBenchRandomGenerator rg = new CBenchRandomGenerator();
|
|
|
|
rg.Set(kBufferSize);
|
|
rg.Generate();
|
|
CRC crc = new CRC();
|
|
crc.Init();
|
|
crc.Update(rg.Buffer, 0, rg.BufferSize);
|
|
|
|
CProgressInfo progressInfo = new CProgressInfo();
|
|
progressInfo.ApprovedStart = dictionarySize;
|
|
|
|
long totalBenchSize = 0;
|
|
long totalEncodeTime = 0;
|
|
long totalDecodeTime = 0;
|
|
long totalCompressedSize = 0;
|
|
|
|
MyInputStream inStream = new MyInputStream(rg.Buffer, rg.BufferSize);
|
|
|
|
byte[] compressedBuffer = new byte[kCompressedBufferSize];
|
|
MyOutputStream compressedStream = new MyOutputStream(compressedBuffer);
|
|
CrcOutStream crcOutStream = new CrcOutStream();
|
|
MyInputStream inputCompressedStream = null;
|
|
int compressedSize = 0;
|
|
for (int i = 0; i < numIterations; i++)
|
|
{
|
|
progressInfo.Init();
|
|
inStream.reset();
|
|
compressedStream.reset();
|
|
encoder.Code(inStream, compressedStream, -1, -1, progressInfo);
|
|
long encodeTime = System.currentTimeMillis() - progressInfo.Time;
|
|
|
|
if (i == 0)
|
|
{
|
|
compressedSize = compressedStream.size();
|
|
inputCompressedStream = new MyInputStream(compressedBuffer, compressedSize);
|
|
}
|
|
else if (compressedSize != compressedStream.size())
|
|
throw (new Exception("Encoding error"));
|
|
|
|
if (progressInfo.InSize == 0)
|
|
throw (new Exception("Internal ERROR 1282"));
|
|
|
|
long decodeTime = 0;
|
|
for (int j = 0; j < 2; j++)
|
|
{
|
|
inputCompressedStream.reset();
|
|
crcOutStream.Init();
|
|
|
|
long outSize = kBufferSize;
|
|
long startTime = System.currentTimeMillis();
|
|
if (!decoder.Code(inputCompressedStream, crcOutStream, outSize))
|
|
throw (new Exception("Decoding Error"));;
|
|
decodeTime = System.currentTimeMillis() - startTime;
|
|
if (crcOutStream.GetDigest() != crc.GetDigest())
|
|
throw (new Exception("CRC Error"));
|
|
}
|
|
long benchSize = kBufferSize - (long)progressInfo.InSize;
|
|
PrintResults(dictionarySize, encodeTime, benchSize, false, 0);
|
|
System.out.print(" ");
|
|
PrintResults(dictionarySize, decodeTime, kBufferSize, true, compressedSize);
|
|
System.out.println();
|
|
|
|
totalBenchSize += benchSize;
|
|
totalEncodeTime += encodeTime;
|
|
totalDecodeTime += decodeTime;
|
|
totalCompressedSize += compressedSize;
|
|
}
|
|
System.out.println("---------------------------------------------------");
|
|
PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);
|
|
System.out.print(" ");
|
|
PrintResults(dictionarySize, totalDecodeTime,
|
|
kBufferSize * (long)numIterations, true, totalCompressedSize);
|
|
System.out.println(" Average");
|
|
return 0;
|
|
}
|
|
}
|