diff options
Diffstat (limited to 'other-licenses/7zstub/src/Java/SevenZip/LzmaBench.java')
| -rw-r--r-- | other-licenses/7zstub/src/Java/SevenZip/LzmaBench.java | 392 |
1 files changed, 392 insertions, 0 deletions
diff --git a/other-licenses/7zstub/src/Java/SevenZip/LzmaBench.java b/other-licenses/7zstub/src/Java/SevenZip/LzmaBench.java new file mode 100644 index 000000000..cceda24da --- /dev/null +++ b/other-licenses/7zstub/src/Java/SevenZip/LzmaBench.java @@ -0,0 +1,392 @@ +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;
+ }
+}
|