Quelle  LzmaBench.java   Sprache: 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;
 }
}