// LzmaBench.cs

using System;

using System.IO;

namespace SevenZip

{

	/// <summary>

	/// LZMA Benchmark

	/// </summary>

	internal abstract class LzmaBench

	{

		const UInt32 kAdditionalSize = (6 << 20);

		const UInt32 kCompressedAdditionalSize = (1 << 10);

		const UInt32 kMaxLzmaPropSize = 10;

		class CRandomGenerator

		{

			UInt32 A1;

			UInt32 A2;

			public CRandomGenerator() { Init(); }

			public void Init() { A1 = 362436069; A2 = 521288629; }

			public UInt32 GetRnd()

			{

				return

					((A1 = 36969 * (A1 & 0xffff) + (A1 >> 16)) << 16) ^

					((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)));

			}

		};

		class CBitRandomGenerator

		{

			CRandomGenerator RG = new CRandomGenerator();

			UInt32 Value;

			int NumBits;

			public void Init()

			{

				Value = 0;

				NumBits = 0;

			}

			public UInt32 GetRnd(int numBits)

			{

				UInt32 result;

				if (NumBits > numBits)

				{

					result = Value & (((UInt32)1 << numBits) - 1);

					Value >>= numBits;

					NumBits -= numBits;

					return result;

				}

				numBits -= NumBits;

				result = (Value << numBits);

				Value = RG.GetRnd();

				result |= Value & (((UInt32)1 << numBits) - 1);

				Value >>= numBits;

				NumBits = 32 - numBits;

				return result;

			}

		};

		class CBenchRandomGenerator

		{

			CBitRandomGenerator RG = new CBitRandomGenerator();

			UInt32 Pos;

			UInt32 Rep0;

			public UInt32 BufferSize;

			public Byte[] Buffer = null;

			public CBenchRandomGenerator() { }

			public void Set(UInt32 bufferSize)

			{

				Buffer = new Byte[bufferSize];

				Pos = 0;

				BufferSize = bufferSize;

			}

			UInt32 GetRndBit() { return RG.GetRnd(1); }

			UInt32 GetLogRandBits(int numBits)

			{

				UInt32 len = RG.GetRnd(numBits);

				return RG.GetRnd((int)len);

			}

			UInt32 GetOffset()

			{

				if (GetRndBit() == 0)

					return GetLogRandBits(4);

				return (GetLogRandBits(4) << 10) | RG.GetRnd(10);

			}

			UInt32 GetLen1() { return RG.GetRnd(1 + (int)RG.GetRnd(2)); }

			UInt32 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

					{

						UInt32 len;

						if (RG.GetRnd(3) == 0)

							len = 1 + GetLen1();

						else

						{

							do

								Rep0 = GetOffset();

							while (Rep0 >= Pos);

							Rep0++;

							len = 2 + GetLen2();

						}

						for (UInt32 i = 0; i < len && Pos < BufferSize; i++, Pos++)

							Buffer[Pos] = Buffer[Pos - Rep0];

					}

				}

			}

		};

		class CrcOutStream : System.IO.Stream

		{

			public CRC CRC = new CRC();

			public void Init() { CRC.Init(); }

			public UInt32 GetDigest() { return CRC.GetDigest(); }

			public override bool CanRead { get { return false; } }

			public override bool CanSeek { get { return false; } }

			public override bool CanWrite { get { return true; } }

			public override Int64 Length { get { return 0; } }

			public override Int64 Position { get { return 0; } set { } }

			public override void Flush() { }

			public override long Seek(long offset, SeekOrigin origin) { return 0; }

			public override void SetLength(long value) { }

			public override int Read(byte[] buffer, int offset, int count) { return 0; }

			public override void WriteByte(byte b)

			{

				CRC.UpdateByte(b);

			}

			public override void Write(byte[] buffer, int offset, int count)

			{

				CRC.Update(buffer, (uint)offset, (uint)count);

			}

		};

		class CProgressInfo : ICodeProgress

		{

			public Int64 ApprovedStart;

			public Int64 InSize;

			public System.DateTime Time;

			public void Init() { InSize = 0; }

			public void SetProgress(Int64 inSize, Int64 outSize)

			{

				if (inSize >= ApprovedStart && InSize == 0)

				{

					Time = DateTime.UtcNow;

					InSize = inSize;

				}

			}

		}

		const int kSubBits = 8;

		static UInt32 GetLogSize(UInt32 size)

		{

			for (int i = kSubBits; i < 32; i++)

				for (UInt32 j = 0; j < (1 << kSubBits); j++)

					if (size <= (((UInt32)1) << i) + (j << (i - kSubBits)))

						return (UInt32)(i << kSubBits) + j;

			return (32 << kSubBits);

		}

		static UInt64 MyMultDiv64(UInt64 value, UInt64 elapsedTime)

		{

			UInt64 freq = TimeSpan.TicksPerSecond;

			UInt64 elTime = elapsedTime;

			while (freq > 1000000)

			{

				freq >>= 1;

				elTime >>= 1;

			}

			if (elTime == 0)

				elTime = 1;

			return value * freq / elTime;

		}

		static UInt64 GetCompressRating(UInt32 dictionarySize, UInt64 elapsedTime, UInt64 size)

		{

			UInt64 t = GetLogSize(dictionarySize) - (18 << kSubBits);

			UInt64 numCommandsForOne = 1060 + ((t * t * 10) >> (2 * kSubBits));

			UInt64 numCommands = (UInt64)(size) * numCommandsForOne;

			return MyMultDiv64(numCommands, elapsedTime);

		}

		static UInt64 GetDecompressRating(UInt64 elapsedTime, UInt64 outSize, UInt64 inSize)

		{

			UInt64 numCommands = inSize * 220 + outSize * 20;

			return MyMultDiv64(numCommands, elapsedTime);

		}

		static UInt64 GetTotalRating(

			UInt32 dictionarySize,

			UInt64 elapsedTimeEn, UInt64 sizeEn,

			UInt64 elapsedTimeDe,

			UInt64 inSizeDe, UInt64 outSizeDe)

		{

			return (GetCompressRating(dictionarySize, elapsedTimeEn, sizeEn) +

				GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;

		}

		static void PrintValue(UInt64 v)

		{

			string s = v.ToString();

			for (int i = 0; i + s.Length < 6; i++)

				System.Console.Write(" ");

			System.Console.Write(s);

		}

		static void PrintRating(UInt64 rating)

		{

			PrintValue(rating / 1000000);

			System.Console.Write(" MIPS");

		}

		static void PrintResults(

			UInt32 dictionarySize,

			UInt64 elapsedTime,

			UInt64 size,

			bool decompressMode, UInt64 secondSize)

		{

			UInt64 speed = MyMultDiv64(size, elapsedTime);

			PrintValue(speed / 1024);

			System.Console.Write(" KB/s  ");

			UInt64 rating;

			if (decompressMode)

				rating = GetDecompressRating(elapsedTime, size, secondSize);

			else

				rating = GetCompressRating(dictionarySize, elapsedTime, size);

			PrintRating(rating);

		}

		static public int LzmaBenchmark(Int32 numIterations, UInt32 dictionarySize)

		{

			if (numIterations <= 0)

				return 0;

			if (dictionarySize < (1 << 18))

			{

				System.Console.WriteLine("\nError: dictionary size for benchmark must be >= 19 (512 KB)");

				return 1;

			}

			System.Console.Write("\n       Compressing                Decompressing\n\n");

			Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();

			Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();

			CoderPropID[] propIDs = 

			{ 

				CoderPropID.DictionarySize,

			};

			object[] properties = 

			{

				(Int32)(dictionarySize),

			};

			UInt32 kBufferSize = dictionarySize + kAdditionalSize;

			UInt32 kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;

			encoder.SetCoderProperties(propIDs, properties);

			System.IO.MemoryStream propStream = new System.IO.MemoryStream();

			encoder.WriteCoderProperties(propStream);

			byte[] propArray = propStream.ToArray();

			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;

			UInt64 totalBenchSize = 0;

			UInt64 totalEncodeTime = 0;

			UInt64 totalDecodeTime = 0;

			UInt64 totalCompressedSize = 0;

			MemoryStream inStream = new MemoryStream(rg.Buffer, 0, (int)rg.BufferSize);

			MemoryStream compressedStream = new MemoryStream((int)kCompressedBufferSize);

			CrcOutStream crcOutStream = new CrcOutStream();

			for (Int32 i = 0; i < numIterations; i++)

			{

				progressInfo.Init();

				inStream.Seek(0, SeekOrigin.Begin);

				compressedStream.Seek(0, SeekOrigin.Begin);

				encoder.Code(inStream, compressedStream, -1, -1, progressInfo);

				TimeSpan sp2 = DateTime.UtcNow - progressInfo.Time;

				UInt64 encodeTime = (UInt64)sp2.Ticks;

				long compressedSize = compressedStream.Position;

				if (progressInfo.InSize == 0)

					throw (new Exception("Internal ERROR 1282"));

				UInt64 decodeTime = 0;

				for (int j = 0; j < 2; j++)

				{

					compressedStream.Seek(0, SeekOrigin.Begin);

					crcOutStream.Init();

					decoder.SetDecoderProperties(propArray);

					UInt64 outSize = kBufferSize;

					System.DateTime startTime = DateTime.UtcNow;

					decoder.Code(compressedStream, crcOutStream, 0, (Int64)outSize, null);

					TimeSpan sp = (DateTime.UtcNow - startTime);

					decodeTime = (ulong)sp.Ticks;

					if (crcOutStream.GetDigest() != crc.GetDigest())

						throw (new Exception("CRC Error"));

				}

				UInt64 benchSize = kBufferSize - (UInt64)progressInfo.InSize;

				PrintResults(dictionarySize, encodeTime, benchSize, false, 0);

				System.Console.Write("     ");

				PrintResults(dictionarySize, decodeTime, kBufferSize, true, (ulong)compressedSize);

				System.Console.WriteLine();

				totalBenchSize += benchSize;

				totalEncodeTime += encodeTime;

				totalDecodeTime += decodeTime;

				totalCompressedSize += (ulong)compressedSize;

			}

			System.Console.WriteLine("---------------------------------------------------");

			PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);

			System.Console.Write("     ");

			PrintResults(dictionarySize, totalDecodeTime,

					kBufferSize * (UInt64)numIterations, true, totalCompressedSize);

			System.Console.WriteLine("    Average");

			return 0;

		}

	}

}