lzma/Java/SevenZip/LzmaBench.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;
	}
}