Annotation of elwix/tools/oldlzma/SRC/7zip/Compress/LZMA_Alone/LzmaBench.cpp, revision 1.1.1.1
1.1 misho 1: // LzmaBench.cpp
2:
3: #include "StdAfx.h"
4:
5: #include "LzmaBench.h"
6:
7: #ifndef _WIN32
8: #include <time.h>
9: #endif
10:
11: #include "../../../Common/CRC.h"
12: #include "../LZMA/LZMADecoder.h"
13: #include "../LZMA/LZMAEncoder.h"
14:
15: static const UInt32 kAdditionalSize =
16: #ifdef _WIN32_WCE
17: (1 << 20);
18: #else
19: (6 << 20);
20: #endif
21:
22: static const UInt32 kCompressedAdditionalSize = (1 << 10);
23: static const UInt32 kMaxLzmaPropSize = 10;
24:
25: class CRandomGenerator
26: {
27: UInt32 A1;
28: UInt32 A2;
29: public:
30: CRandomGenerator() { Init(); }
31: void Init() { A1 = 362436069; A2 = 521288629;}
32: UInt32 GetRnd()
33: {
34: return
35: ((A1 = 36969 * (A1 & 0xffff) + (A1 >> 16)) << 16) ^
36: ((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)) );
37: }
38: };
39:
40: class CBitRandomGenerator
41: {
42: CRandomGenerator RG;
43: UInt32 Value;
44: int NumBits;
45: public:
46: void Init()
47: {
48: Value = 0;
49: NumBits = 0;
50: }
51: UInt32 GetRnd(int numBits)
52: {
53: if (NumBits > numBits)
54: {
55: UInt32 result = Value & ((1 << numBits) - 1);
56: Value >>= numBits;
57: NumBits -= numBits;
58: return result;
59: }
60: numBits -= NumBits;
61: UInt32 result = (Value << numBits);
62: Value = RG.GetRnd();
63: result |= Value & ((1 << numBits) - 1);
64: Value >>= numBits;
65: NumBits = 32 - numBits;
66: return result;
67: }
68: };
69:
70: class CBenchRandomGenerator
71: {
72: CBitRandomGenerator RG;
73: UInt32 Pos;
74: public:
75: UInt32 BufferSize;
76: Byte *Buffer;
77: CBenchRandomGenerator(): Buffer(0) {}
78: ~CBenchRandomGenerator() { delete []Buffer; }
79: void Init() { RG.Init(); }
80: void Set(UInt32 bufferSize)
81: {
82: delete []Buffer;
83: Buffer = 0;
84: Buffer = new Byte[bufferSize];
85: Pos = 0;
86: BufferSize = bufferSize;
87: }
88: UInt32 GetRndBit() { return RG.GetRnd(1); }
89: /*
90: UInt32 GetLogRand(int maxLen)
91: {
92: UInt32 len = GetRnd() % (maxLen + 1);
93: return GetRnd() & ((1 << len) - 1);
94: }
95: */
96: UInt32 GetLogRandBits(int numBits)
97: {
98: UInt32 len = RG.GetRnd(numBits);
99: return RG.GetRnd(len);
100: }
101: UInt32 GetOffset()
102: {
103: if (GetRndBit() == 0)
104: return GetLogRandBits(4);
105: return (GetLogRandBits(4) << 10) | RG.GetRnd(10);
106: }
107: UInt32 GetLen()
108: {
109: if (GetRndBit() == 0)
110: return RG.GetRnd(2);
111: if (GetRndBit() == 0)
112: return 4 + RG.GetRnd(3);
113: return 12 + RG.GetRnd(4);
114: }
115: void Generate()
116: {
117: while(Pos < BufferSize)
118: {
119: if (GetRndBit() == 0 || Pos < 1)
120: Buffer[Pos++] = Byte(RG.GetRnd(8));
121: else
122: {
123: UInt32 offset = GetOffset();
124: while (offset >= Pos)
125: offset >>= 1;
126: offset += 1;
127: UInt32 len = 2 + GetLen();
128: for (UInt32 i = 0; i < len && Pos < BufferSize; i++, Pos++)
129: Buffer[Pos] = Buffer[Pos - offset];
130: }
131: }
132: }
133: };
134:
135: class CBenchmarkInStream:
136: public ISequentialInStream,
137: public CMyUnknownImp
138: {
139: const Byte *Data;
140: UInt32 Pos;
141: UInt32 Size;
142: public:
143: MY_UNKNOWN_IMP
144: void Init(const Byte *data, UInt32 size)
145: {
146: Data = data;
147: Size = size;
148: Pos = 0;
149: }
150: STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
151: STDMETHOD(ReadPart)(void *data, UInt32 size, UInt32 *processedSize);
152: };
153:
154: STDMETHODIMP CBenchmarkInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
155: {
156: UInt32 remain = Size - Pos;
157: if (size > remain)
158: size = remain;
159: for (UInt32 i = 0; i < size; i++)
160: {
161: ((Byte *)data)[i] = Data[Pos + i];
162: }
163: Pos += size;
164: if(processedSize != NULL)
165: *processedSize = size;
166: return S_OK;
167: }
168:
169: STDMETHODIMP CBenchmarkInStream::ReadPart(void *data, UInt32 size, UInt32 *processedSize)
170: {
171: return Read(data, size, processedSize);
172: }
173:
174: class CBenchmarkOutStream:
175: public ISequentialOutStream,
176: public CMyUnknownImp
177: {
178: UInt32 BufferSize;
179: FILE *_f;
180: public:
181: UInt32 Pos;
182: Byte *Buffer;
183: CBenchmarkOutStream(): _f(0), Buffer(0) {}
184: virtual ~CBenchmarkOutStream() { delete []Buffer; }
185: void Init(FILE *f, UInt32 bufferSize)
186: {
187: delete []Buffer;
188: Buffer = 0;
189: Buffer = new Byte[bufferSize];
190: Pos = 0;
191: BufferSize = bufferSize;
192: _f = f;
193: }
194: MY_UNKNOWN_IMP
195: STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
196: STDMETHOD(WritePart)(const void *data, UInt32 size, UInt32 *processedSize);
197: };
198:
199: STDMETHODIMP CBenchmarkOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
200: {
201: UInt32 i;
202: for (i = 0; i < size && Pos < BufferSize; i++)
203: Buffer[Pos++] = ((const Byte *)data)[i];
204: if(processedSize != NULL)
205: *processedSize = i;
206: if (i != size)
207: {
208: fprintf(_f, "\nERROR: Buffer is full\n");
209: return E_FAIL;
210: }
211: return S_OK;
212: }
213:
214: STDMETHODIMP CBenchmarkOutStream::WritePart(const void *data, UInt32 size, UInt32 *processedSize)
215: {
216: return Write(data, size, processedSize);
217: }
218:
219: class CCrcOutStream:
220: public ISequentialOutStream,
221: public CMyUnknownImp
222: {
223: public:
224: CCRC CRC;
225: MY_UNKNOWN_IMP
226: void Init() { CRC.Init(); }
227: STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
228: STDMETHOD(WritePart)(const void *data, UInt32 size, UInt32 *processedSize);
229: };
230:
231: STDMETHODIMP CCrcOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
232: {
233: CRC.Update(data, size);
234: if(processedSize != NULL)
235: *processedSize = size;
236: return S_OK;
237: }
238:
239: STDMETHODIMP CCrcOutStream::WritePart(const void *data, UInt32 size, UInt32 *processedSize)
240: {
241: return Write(data, size, processedSize);
242: }
243:
244: static UInt64 GetTimeCount()
245: {
246: #ifdef _WIN32
247: LARGE_INTEGER value;
248: if (::QueryPerformanceCounter(&value))
249: return value.QuadPart;
250: return GetTickCount();
251: #else
252: return clock();
253: #endif
254: }
255:
256: static UInt64 GetFreq()
257: {
258: #ifdef _WIN32
259: LARGE_INTEGER value;
260: if (::QueryPerformanceFrequency(&value))
261: return value.QuadPart;
262: return 1000;
263: #else
264: return CLOCKS_PER_SEC;
265: #endif
266: }
267:
268: struct CProgressInfo:
269: public ICompressProgressInfo,
270: public CMyUnknownImp
271: {
272: UInt64 ApprovedStart;
273: UInt64 InSize;
274: UInt64 Time;
275: void Init()
276: {
277: InSize = 0;
278: Time = 0;
279: }
280: MY_UNKNOWN_IMP
281: STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
282: };
283:
284: STDMETHODIMP CProgressInfo::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
285: {
286: if (*inSize >= ApprovedStart && InSize == 0)
287: {
288: Time = ::GetTimeCount();
289: InSize = *inSize;
290: }
291: return S_OK;
292: }
293:
294: static const int kSubBits = 8;
295:
296: static UInt32 GetLogSize(UInt32 size)
297: {
298: for (int i = kSubBits; i < 32; i++)
299: for (UInt32 j = 0; j < (1 << kSubBits); j++)
300: if (size <= (((UInt32)1) << i) + (j << (i - kSubBits)))
301: return (i << kSubBits) + j;
302: return (32 << kSubBits);
303: }
304:
305: static UInt64 MyMultDiv64(UInt64 value, UInt64 elapsedTime)
306: {
307: UInt64 freq = GetFreq();
308: UInt64 elTime = elapsedTime;
309: while(freq > 1000000)
310: {
311: freq >>= 1;
312: elTime >>= 1;
313: }
314: if (elTime == 0)
315: elTime = 1;
316: return value * freq / elTime;
317: }
318:
319: static UInt64 GetCompressRating(UInt32 dictionarySize, bool isBT4,
320: UInt64 elapsedTime, UInt64 size)
321: {
322: UInt64 numCommandsForOne;
323: if (isBT4)
324: {
325: UInt64 t = GetLogSize(dictionarySize) - (19 << kSubBits);
326: numCommandsForOne = 2000 + ((t * t * 68) >> (2 * kSubBits));
327: }
328: else
329: {
330: UInt64 t = GetLogSize(dictionarySize) - (15 << kSubBits);
331: numCommandsForOne = 1500 + ((t * t * 41) >> (2 * kSubBits));
332: }
333: UInt64 numCommands = (UInt64)(size) * numCommandsForOne;
334: return MyMultDiv64(numCommands, elapsedTime);
335: }
336:
337: static UInt64 GetDecompressRating(UInt64 elapsedTime,
338: UInt64 outSize, UInt64 inSize)
339: {
340: UInt64 numCommands = inSize * 250 + outSize * 21;
341: return MyMultDiv64(numCommands, elapsedTime);
342: }
343:
344: /*
345: static UInt64 GetTotalRating(
346: UInt32 dictionarySize,
347: bool isBT4,
348: UInt64 elapsedTimeEn, UInt64 sizeEn,
349: UInt64 elapsedTimeDe,
350: UInt64 inSizeDe, UInt64 outSizeDe)
351: {
352: return (GetCompressRating(dictionarySize, isBT4, elapsedTimeEn, sizeEn) +
353: GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;
354: }
355: */
356:
357: static void PrintRating(FILE *f, UInt64 rating)
358: {
359: fprintf(f, "%5d MIPS", (unsigned int)(rating / 1000000));
360: }
361:
362: static void PrintResults(
363: FILE *f,
364: UInt32 dictionarySize,
365: bool isBT4,
366: UInt64 elapsedTime,
367: UInt64 size,
368: bool decompressMode, UInt64 secondSize)
369: {
370: UInt64 speed = MyMultDiv64(size, elapsedTime);
371: fprintf(f, "%6d KB/s ", (unsigned int)(speed / 1024));
372: UInt64 rating;
373: if (decompressMode)
374: rating = GetDecompressRating(elapsedTime, size, secondSize);
375: else
376: rating = GetCompressRating(dictionarySize, isBT4, elapsedTime, size);
377: PrintRating(f, rating);
378: }
379:
380: static void ThrowError(FILE *f, HRESULT result, const char *s)
381: {
382: fprintf(f, "\nError: ");
383: if (result == E_ABORT)
384: fprintf(f, "User break");
385: if (result == E_OUTOFMEMORY)
386: fprintf(f, "Can not allocate memory");
387: else
388: fprintf(f, s);
389: fprintf(f, "\n");
390: }
391:
392: const wchar_t *bt2 = L"BT2";
393: const wchar_t *bt4 = L"BT4";
394:
395: int LzmaBenchmark(FILE *f, UInt32 numIterations, UInt32 dictionarySize, bool isBT4)
396: {
397: if (numIterations == 0)
398: return 0;
399: if (dictionarySize < (1 << 19) && isBT4 || dictionarySize < (1 << 15))
400: {
401: fprintf(f, "\nError: dictionary size for benchmark must be >= 19 (512 KB)\n");
402: return 1;
403: }
404: fprintf(f, "\n Compressing Decompressing\n\n");
405: NCompress::NLZMA::CEncoder *encoderSpec = new NCompress::NLZMA::CEncoder;
406: CMyComPtr<ICompressCoder> encoder = encoderSpec;
407:
408: NCompress::NLZMA::CDecoder *decoderSpec = new NCompress::NLZMA::CDecoder;
409: CMyComPtr<ICompressCoder> decoder = decoderSpec;
410:
411: CBenchmarkOutStream *propStreamSpec = new CBenchmarkOutStream;
412: CMyComPtr<ISequentialOutStream> propStream = propStreamSpec;
413: propStreamSpec->Init(f, kMaxLzmaPropSize);
414:
415: PROPID propIDs[] =
416: {
417: NCoderPropID::kDictionarySize,
418: NCoderPropID::kMatchFinder
419: };
420: const int kNumProps = sizeof(propIDs) / sizeof(propIDs[0]);
421: PROPVARIANT properties[kNumProps];
422: properties[0].vt = VT_UI4;
423: properties[0].ulVal = UInt32(dictionarySize);
424:
425: properties[1].vt = VT_BSTR;
426: properties[1].bstrVal = isBT4 ? (BSTR)bt4: (BSTR)bt2;
427:
428: const UInt32 kBufferSize = dictionarySize + kAdditionalSize;
429: const UInt32 kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;
430:
431: if (encoderSpec->SetCoderProperties(propIDs, properties, kNumProps) != S_OK)
432: {
433: fprintf(f, "\nError: Incorrect command\n");
434: return 1;
435: }
436: encoderSpec->WriteCoderProperties(propStream);
437:
438: CBenchRandomGenerator rg;
439: rg.Init();
440: rg.Set(kBufferSize);
441: rg.Generate();
442: CCRC crc;
443: crc.Update(rg.Buffer, rg.BufferSize);
444:
445: CProgressInfo *progressInfoSpec = new CProgressInfo;
446: CMyComPtr<ICompressProgressInfo> progressInfo = progressInfoSpec;
447:
448: progressInfoSpec->ApprovedStart = dictionarySize;
449:
450: UInt64 totalBenchSize = 0;
451: UInt64 totalEncodeTime = 0;
452: UInt64 totalDecodeTime = 0;
453: UInt64 totalCompressedSize = 0;
454:
455: for (UInt32 i = 0; i < numIterations; i++)
456: {
457: progressInfoSpec->Init();
458: CBenchmarkInStream *inStreamSpec = new CBenchmarkInStream;
459: inStreamSpec->Init(rg.Buffer, rg.BufferSize);
460: CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
461: CBenchmarkOutStream *outStreamSpec = new CBenchmarkOutStream;
462: outStreamSpec->Init(f, kCompressedBufferSize);
463: CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
464: HRESULT result = encoder->Code(inStream, outStream, 0, 0, progressInfo);
465: UInt64 encodeTime = ::GetTimeCount() - progressInfoSpec->Time;
466: UInt32 compressedSize = outStreamSpec->Pos;
467: if(result != S_OK)
468: {
469: ThrowError(f, result, "Encoder Error");
470: return 1;
471: }
472: if (progressInfoSpec->InSize == 0)
473: {
474: fprintf(f, "\nError: Internal ERROR 1282\n");
475: return 1;
476: }
477:
478: ///////////////////////
479: // Decompressing
480:
481: CCrcOutStream *crcOutStreamSpec = new CCrcOutStream;
482: CMyComPtr<ISequentialOutStream> crcOutStream = crcOutStreamSpec;
483:
484: UInt64 decodeTime;
485: for (int j = 0; j < 2; j++)
486: {
487: inStreamSpec->Init(outStreamSpec->Buffer, compressedSize);
488: crcOutStreamSpec->Init();
489:
490: if (decoderSpec->SetDecoderProperties2(propStreamSpec->Buffer, propStreamSpec->Pos) != S_OK)
491: {
492: fprintf(f, "\nError: Set Decoder Properties Error\n");
493: return 1;
494: }
495: UInt64 outSize = kBufferSize;
496: UInt64 startTime = ::GetTimeCount();
497: result = decoder->Code(inStream, crcOutStream, 0, &outSize, 0);
498: decodeTime = ::GetTimeCount() - startTime;
499: if(result != S_OK)
500: {
501: ThrowError(f, result, "Decode Error");
502: return 1;
503: }
504: if (crcOutStreamSpec->CRC.GetDigest() != crc.GetDigest())
505: {
506: fprintf(f, "\nError: CRC Error\n");
507: return 1;
508: }
509: }
510: UInt64 benchSize = kBufferSize - progressInfoSpec->InSize;
511: PrintResults(f, dictionarySize, isBT4, encodeTime, benchSize, false, 0);
512: fprintf(f, " ");
513: PrintResults(f, dictionarySize, isBT4, decodeTime, kBufferSize, true, compressedSize);
514: fprintf(f, "\n");
515:
516: totalBenchSize += benchSize;
517: totalEncodeTime += encodeTime;
518: totalDecodeTime += decodeTime;
519: totalCompressedSize += compressedSize;
520: }
521: fprintf(f, "---------------------------------------------------\n");
522: PrintResults(f, dictionarySize, isBT4, totalEncodeTime, totalBenchSize, false, 0);
523: fprintf(f, " ");
524: PrintResults(f, dictionarySize, isBT4, totalDecodeTime,
525: kBufferSize * numIterations, true, totalCompressedSize);
526: fprintf(f, " Average\n");
527: return 0;
528: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to LzmaBench.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / oldlzma / SRC / 7zip / Compress / LZMA_Alone