mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
341 lines
9.5 KiB
C#
341 lines
9.5 KiB
C#
// 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;
|
|
}
|
|
}
|
|
}
|