vcs.maemo.org Git - physicsfs/blob - lzma/CS/7zip/Compress/LzmaAlone/LzmaBench.cs

   1 // LzmaBench.cs
   2
   3 using System;
   4 using System.IO;
   5
   6 namespace SevenZip
   7 {
   8         /// <summary>
   9         /// LZMA Benchmark
  10         /// </summary>
  11         internal abstract class LzmaBench
  12         {
  13                 const UInt32 kAdditionalSize = (6 << 20);
  14                 const UInt32 kCompressedAdditionalSize = (1 << 10);
  15                 const UInt32 kMaxLzmaPropSize = 10;
  16
  17                 class CRandomGenerator
  18                 {
  19                         UInt32 A1;
  20                         UInt32 A2;
  21                         public CRandomGenerator() { Init(); }
  22                         public void Init() { A1 = 362436069; A2 = 521288629; }
  23                         public UInt32 GetRnd()
  24                         {
  25                                 return
  26                                         ((A1 = 36969 * (A1 & 0xffff) + (A1 >> 16)) << 16) ^
  27                                         ((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)));
  28                         }
  29                 };
  30
  31                 class CBitRandomGenerator
  32                 {
  33                         CRandomGenerator RG = new CRandomGenerator();
  34                         UInt32 Value;
  35                         int NumBits;
  36                         public void Init()
  37                         {
  38                                 Value = 0;
  39                                 NumBits = 0;
  40                         }
  41                         public UInt32 GetRnd(int numBits)
  42                         {
  43                                 UInt32 result;
  44                                 if (NumBits > numBits)
  45                                 {
  46                                         result = Value & (((UInt32)1 << numBits) - 1);
  47                                         Value >>= numBits;
  48                                         NumBits -= numBits;
  49                                         return result;
  50                                 }
  51                                 numBits -= NumBits;
  52                                 result = (Value << numBits);
  53                                 Value = RG.GetRnd();
  54                                 result |= Value & (((UInt32)1 << numBits) - 1);
  55                                 Value >>= numBits;
  56                                 NumBits = 32 - numBits;
  57                                 return result;
  58                         }
  59                 };
  60
  61                 class CBenchRandomGenerator
  62                 {
  63                         CBitRandomGenerator RG = new CBitRandomGenerator();
  64                         UInt32 Pos;
  65                         UInt32 Rep0;
  66
  67                         public UInt32 BufferSize;
  68                         public Byte[] Buffer = null;
  69
  70                         public CBenchRandomGenerator() { }
  71
  72                         public void Set(UInt32 bufferSize)
  73                         {
  74                                 Buffer = new Byte[bufferSize];
  75                                 Pos = 0;
  76                                 BufferSize = bufferSize;
  77                         }
  78                         UInt32 GetRndBit() { return RG.GetRnd(1); }
  79                         UInt32 GetLogRandBits(int numBits)
  80                         {
  81                                 UInt32 len = RG.GetRnd(numBits);
  82                                 return RG.GetRnd((int)len);
  83                         }
  84                         UInt32 GetOffset()
  85                         {
  86                                 if (GetRndBit() == 0)
  87                                         return GetLogRandBits(4);
  88                                 return (GetLogRandBits(4) << 10) | RG.GetRnd(10);
  89                         }
  90                         UInt32 GetLen1() { return RG.GetRnd(1 + (int)RG.GetRnd(2)); }
  91                         UInt32 GetLen2() { return RG.GetRnd(2 + (int)RG.GetRnd(2)); }
  92                         public void Generate()
  93                         {
  94                                 RG.Init();
  95                                 Rep0 = 1;
  96                                 while (Pos < BufferSize)
  97                                 {
  98                                         if (GetRndBit() == 0 || Pos < 1)
  99                                                 Buffer[Pos++] = (Byte)RG.GetRnd(8);
 100                                         else
 101                                         {
 102                                                 UInt32 len;
 103                                                 if (RG.GetRnd(3) == 0)
 104                                                         len = 1 + GetLen1();
 105                                                 else
 106                                                 {
 107                                                         do
 108                                                                 Rep0 = GetOffset();
 109                                                         while (Rep0 >= Pos);
 110                                                         Rep0++;
 111                                                         len = 2 + GetLen2();
 112                                                 }
 113                                                 for (UInt32 i = 0; i < len && Pos < BufferSize; i++, Pos++)
 114                                                         Buffer[Pos] = Buffer[Pos - Rep0];
 115                                         }
 116                                 }
 117                         }
 118                 };
 119
 120                 class CrcOutStream : System.IO.Stream
 121                 {
 122                         public CRC CRC = new CRC();
 123                         public void Init() { CRC.Init(); }
 124                         public UInt32 GetDigest() { return CRC.GetDigest(); }
 125
 126                         public override bool CanRead { get { return false; } }
 127                         public override bool CanSeek { get { return false; } }
 128                         public override bool CanWrite { get { return true; } }
 129                         public override Int64 Length { get { return 0; } }
 130                         public override Int64 Position { get { return 0; } set { } }
 131                         public override void Flush() { }
 132                         public override long Seek(long offset, SeekOrigin origin) { return 0; }
 133                         public override void SetLength(long value) { }
 134                         public override int Read(byte[] buffer, int offset, int count) { return 0; }
 135
 136                         public override void WriteByte(byte b)
 137                         {
 138                                 CRC.UpdateByte(b);
 139                         }
 140                         public override void Write(byte[] buffer, int offset, int count)
 141                         {
 142                                 CRC.Update(buffer, (uint)offset, (uint)count);
 143                         }
 144                 };
 145
 146                 class CProgressInfo : ICodeProgress
 147                 {
 148                         public Int64 ApprovedStart;
 149                         public Int64 InSize;
 150                         public System.DateTime Time;
 151                         public void Init() { InSize = 0; }
 152                         public void SetProgress(Int64 inSize, Int64 outSize)
 153                         {
 154                                 if (inSize >= ApprovedStart && InSize == 0)
 155                                 {
 156                                         Time = DateTime.UtcNow;
 157                                         InSize = inSize;
 158                                 }
 159                         }
 160                 }
 161                 const int kSubBits = 8;
 162
 163                 static UInt32 GetLogSize(UInt32 size)
 164                 {
 165                         for (int i = kSubBits; i < 32; i++)
 166                                 for (UInt32 j = 0; j < (1 << kSubBits); j++)
 167                                         if (size <= (((UInt32)1) << i) + (j << (i - kSubBits)))
 168                                                 return (UInt32)(i << kSubBits) + j;
 169                         return (32 << kSubBits);
 170                 }
 171
 172                 static UInt64 MyMultDiv64(UInt64 value, UInt64 elapsedTime)
 173                 {
 174                         UInt64 freq = TimeSpan.TicksPerSecond;
 175                         UInt64 elTime = elapsedTime;
 176                         while (freq > 1000000)
 177                         {
 178                                 freq >>= 1;
 179                                 elTime >>= 1;
 180                         }
 181                         if (elTime == 0)
 182                                 elTime = 1;
 183                         return value * freq / elTime;
 184                 }
 185
 186                 static UInt64 GetCompressRating(UInt32 dictionarySize, UInt64 elapsedTime, UInt64 size)
 187                 {
 188                         UInt64 t = GetLogSize(dictionarySize) - (18 << kSubBits);
 189                         UInt64 numCommandsForOne = 1060 + ((t * t * 10) >> (2 * kSubBits));
 190                         UInt64 numCommands = (UInt64)(size) * numCommandsForOne;
 191                         return MyMultDiv64(numCommands, elapsedTime);
 192                 }
 193
 194                 static UInt64 GetDecompressRating(UInt64 elapsedTime, UInt64 outSize, UInt64 inSize)
 195                 {
 196                         UInt64 numCommands = inSize * 220 + outSize * 20;
 197                         return MyMultDiv64(numCommands, elapsedTime);
 198                 }
 199
 200                 static UInt64 GetTotalRating(
 201                         UInt32 dictionarySize,
 202                         UInt64 elapsedTimeEn, UInt64 sizeEn,
 203                         UInt64 elapsedTimeDe,
 204                         UInt64 inSizeDe, UInt64 outSizeDe)
 205                 {
 206                         return (GetCompressRating(dictionarySize, elapsedTimeEn, sizeEn) +
 207                                 GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;
 208                 }
 209
 210                 static void PrintValue(UInt64 v)
 211                 {
 212                         string s = v.ToString();
 213                         for (int i = 0; i + s.Length < 6; i++)
 214                                 System.Console.Write(" ");
 215                         System.Console.Write(s);
 216                 }
 217
 218                 static void PrintRating(UInt64 rating)
 219                 {
 220                         PrintValue(rating / 1000000);
 221                         System.Console.Write(" MIPS");
 222                 }
 223
 224                 static void PrintResults(
 225                         UInt32 dictionarySize,
 226                         UInt64 elapsedTime,
 227                         UInt64 size,
 228                         bool decompressMode, UInt64 secondSize)
 229                 {
 230                         UInt64 speed = MyMultDiv64(size, elapsedTime);
 231                         PrintValue(speed / 1024);
 232                         System.Console.Write(" KB/s  ");
 233                         UInt64 rating;
 234                         if (decompressMode)
 235                                 rating = GetDecompressRating(elapsedTime, size, secondSize);
 236                         else
 237                                 rating = GetCompressRating(dictionarySize, elapsedTime, size);
 238                         PrintRating(rating);
 239                 }
 240
 241                 static public int LzmaBenchmark(Int32 numIterations, UInt32 dictionarySize)
 242                 {
 243                         if (numIterations <= 0)
 244                                 return 0;
 245                         if (dictionarySize < (1 << 18))
 246                         {
 247                                 System.Console.WriteLine("\nError: dictionary size for benchmark must be >= 19 (512 KB)");
 248                                 return 1;
 249                         }
 250                         System.Console.Write("\n       Compressing                Decompressing\n\n");
 251
 252                         Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();
 253                         Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();
 254
 255
 256                         CoderPropID[] propIDs =
 257                         {
 258                                 CoderPropID.DictionarySize,
 259                         };
 260                         object[] properties =
 261                         {
 262                                 (Int32)(dictionarySize),
 263                         };
 264
 265                         UInt32 kBufferSize = dictionarySize + kAdditionalSize;
 266                         UInt32 kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;
 267
 268                         encoder.SetCoderProperties(propIDs, properties);
 269                         System.IO.MemoryStream propStream = new System.IO.MemoryStream();
 270                         encoder.WriteCoderProperties(propStream);
 271                         byte[] propArray = propStream.ToArray();
 272
 273                         CBenchRandomGenerator rg = new CBenchRandomGenerator();
 274
 275                         rg.Set(kBufferSize);
 276                         rg.Generate();
 277                         CRC crc = new CRC();
 278                         crc.Init();
 279                         crc.Update(rg.Buffer, 0, rg.BufferSize);
 280
 281                         CProgressInfo progressInfo = new CProgressInfo();
 282                         progressInfo.ApprovedStart = dictionarySize;
 283
 284                         UInt64 totalBenchSize = 0;
 285                         UInt64 totalEncodeTime = 0;
 286                         UInt64 totalDecodeTime = 0;
 287                         UInt64 totalCompressedSize = 0;
 288
 289                         MemoryStream inStream = new MemoryStream(rg.Buffer, 0, (int)rg.BufferSize);
 290                         MemoryStream compressedStream = new MemoryStream((int)kCompressedBufferSize);
 291                         CrcOutStream crcOutStream = new CrcOutStream();
 292                         for (Int32 i = 0; i < numIterations; i++)
 293                         {
 294                                 progressInfo.Init();
 295                                 inStream.Seek(0, SeekOrigin.Begin);
 296                                 compressedStream.Seek(0, SeekOrigin.Begin);
 297                                 encoder.Code(inStream, compressedStream, -1, -1, progressInfo);
 298                                 TimeSpan sp2 = DateTime.UtcNow - progressInfo.Time;
 299                                 UInt64 encodeTime = (UInt64)sp2.Ticks;
 300
 301                                 long compressedSize = compressedStream.Position;
 302                                 if (progressInfo.InSize == 0)
 303                                         throw (new Exception("Internal ERROR 1282"));
 304
 305                                 UInt64 decodeTime = 0;
 306                                 for (int j = 0; j < 2; j++)
 307                                 {
 308                                         compressedStream.Seek(0, SeekOrigin.Begin);
 309                                         crcOutStream.Init();
 310
 311                                         decoder.SetDecoderProperties(propArray);
 312                                         UInt64 outSize = kBufferSize;
 313                                         System.DateTime startTime = DateTime.UtcNow;
 314                                         decoder.Code(compressedStream, crcOutStream, 0, (Int64)outSize, null);
 315                                         TimeSpan sp = (DateTime.UtcNow - startTime);
 316                                         decodeTime = (ulong)sp.Ticks;
 317                                         if (crcOutStream.GetDigest() != crc.GetDigest())
 318                                                 throw (new Exception("CRC Error"));
 319                                 }
 320                                 UInt64 benchSize = kBufferSize - (UInt64)progressInfo.InSize;
 321                                 PrintResults(dictionarySize, encodeTime, benchSize, false, 0);
 322                                 System.Console.Write("     ");
 323                                 PrintResults(dictionarySize, decodeTime, kBufferSize, true, (ulong)compressedSize);
 324                                 System.Console.WriteLine();
 325
 326                                 totalBenchSize += benchSize;
 327                                 totalEncodeTime += encodeTime;
 328                                 totalDecodeTime += decodeTime;
 329                                 totalCompressedSize += (ulong)compressedSize;
 330                         }
 331                         System.Console.WriteLine("---------------------------------------------------");
 332                         PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);
 333                         System.Console.Write("     ");
 334                         PrintResults(dictionarySize, totalDecodeTime,
 335                                         kBufferSize * (UInt64)numIterations, true, totalCompressedSize);
 336                         System.Console.WriteLine("    Average");
 337                         return 0;
 338                 }
 339         }
 340 }