zlib/contrib/testzlib/testzlib.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <windows.h>
   4
   5 #include "zlib.h"
   6
   7
   8 void MyDoMinus64(LARGE_INTEGER *R,LARGE_INTEGER A,LARGE_INTEGER B)
   9 {
  10     R->HighPart = A.HighPart - B.HighPart;
  11     if (A.LowPart >= B.LowPart)
  12         R->LowPart = A.LowPart - B.LowPart;
  13     else
  14     {
  15         R->LowPart = A.LowPart - B.LowPart;
  16         R->HighPart --;
  17     }
  18 }
  19
  20 #ifdef _M_X64
  21 // see http://msdn2.microsoft.com/library/twchhe95(en-us,vs.80).aspx for __rdtsc
  22 unsigned __int64 __rdtsc(void);
  23 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
  24 {
  25  //   printf("rdtsc = %I64x\n",__rdtsc());
  26    pbeginTime64->QuadPart=__rdtsc();
  27 }
  28
  29 LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
  30 {
  31     LARGE_INTEGER LIres;
  32     unsigned _int64 res=__rdtsc()-((unsigned _int64)(beginTime64.QuadPart));
  33     LIres.QuadPart=res;
  34    // printf("rdtsc = %I64x\n",__rdtsc());
  35     return LIres;
  36 }
  37 #else
  38 #ifdef _M_IX86
  39 void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
  40 {
  41     DWORD dwEdx,dwEax;
  42     _asm
  43     {
  44         rdtsc
  45         mov dwEax,eax
  46         mov dwEdx,edx
  47     }
  48     pbeginTime64->LowPart=dwEax;
  49     pbeginTime64->HighPart=dwEdx;
  50 }
  51
  52 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
  53 {
  54     myGetRDTSC32(pbeginTime64);
  55 }
  56
  57 LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
  58 {
  59     LARGE_INTEGER LIres,endTime64;
  60     myGetRDTSC32(&endTime64);
  61
  62     LIres.LowPart=LIres.HighPart=0;
  63     MyDoMinus64(&LIres,endTime64,beginTime64);
  64     return LIres;
  65 }
  66 #else
  67 void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
  68 {
  69 }
  70
  71 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
  72 {
  73 }
  74
  75 LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
  76 {
  77     LARGE_INTEGER lr;
  78     lr.QuadPart=0;
  79     return lr;
  80 }
  81 #endif
  82 #endif
  83
  84 void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
  85 {
  86     if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
  87     {
  88         pbeginTime64->LowPart = GetTickCount();
  89         pbeginTime64->HighPart = 0;
  90     }
  91 }
  92
  93 DWORD GetMsecSincePerfCounter(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
  94 {
  95     LARGE_INTEGER endTime64,ticksPerSecond,ticks;
  96     DWORDLONG ticksShifted,tickSecShifted;
  97     DWORD dwLog=16+0;
  98     DWORD dwRet;
  99     if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(&endTime64)))
 100         dwRet = (GetTickCount() - beginTime64.LowPart)*1;
 101     else
 102     {
 103         MyDoMinus64(&ticks,endTime64,beginTime64);
 104         QueryPerformanceFrequency(&ticksPerSecond);
 105
 106
 107         {
 108             ticksShifted = Int64ShrlMod32(*(DWORDLONG*)&ticks,dwLog);
 109             tickSecShifted = Int64ShrlMod32(*(DWORDLONG*)&ticksPerSecond,dwLog);
 110
 111         }
 112
 113         dwRet = (DWORD)((((DWORD)ticksShifted)*1000)/(DWORD)(tickSecShifted));
 114         dwRet *=1;
 115     }
 116     return dwRet;
 117 }
 118
 119 int ReadFileMemory(const char* filename,long* plFileSize,unsigned char** pFilePtr)
 120 {
 121     FILE* stream;
 122     unsigned char* ptr;
 123     int retVal=1;
 124     stream=fopen(filename, "rb");
 125     if (stream==NULL)
 126         return 0;
 127
 128     fseek(stream,0,SEEK_END);
 129
 130     *plFileSize=ftell(stream);
 131     fseek(stream,0,SEEK_SET);
 132     ptr=malloc((*plFileSize)+1);
 133     if (ptr==NULL)
 134         retVal=0;
 135     else
 136     {
 137         if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize))
 138             retVal=0;
 139     }
 140     fclose(stream);
 141     *pFilePtr=ptr;
 142     return retVal;
 143 }
 144
 145 int main(int argc, char *argv[])
 146 {
 147     int BlockSizeCompress=0x8000;
 148     int BlockSizeUncompress=0x8000;
 149     int cprLevel=Z_DEFAULT_COMPRESSION ;
 150     long lFileSize;
 151     unsigned char* FilePtr;
 152     long lBufferSizeCpr;
 153     long lBufferSizeUncpr;
 154     long lCompressedSize=0;
 155     unsigned char* CprPtr;
 156     unsigned char* UncprPtr;
 157     long lSizeCpr,lSizeUncpr;
 158     DWORD dwGetTick,dwMsecQP;
 159     LARGE_INTEGER li_qp,li_rdtsc,dwResRdtsc;
 160
 161     if (argc<=1)
 162     {
 163         printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
 164         return 0;
 165     }
 166
 167     if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
 168     {
 169         printf("error reading %s\n",argv[1]);
 170         return 1;
 171     }
 172     else printf("file %s read, %u bytes\n",argv[1],lFileSize);
 173
 174     if (argc>=3)
 175         BlockSizeCompress=atol(argv[2]);
 176
 177     if (argc>=4)
 178         BlockSizeUncompress=atol(argv[3]);
 179
 180     if (argc>=5)
 181         cprLevel=(int)atol(argv[4]);
 182
 183     lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
 184     lBufferSizeUncpr = lBufferSizeCpr;
 185
 186     CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
 187
 188     BeginCountPerfCounter(&li_qp,TRUE);
 189     dwGetTick=GetTickCount();
 190     BeginCountRdtsc(&li_rdtsc);
 191     {
 192         z_stream zcpr;
 193         int ret=Z_OK;
 194         long lOrigToDo = lFileSize;
 195         long lOrigDone = 0;
 196         int step=0;
 197         memset(&zcpr,0,sizeof(z_stream));
 198         deflateInit(&zcpr,cprLevel);
 199
 200         zcpr.next_in = FilePtr;
 201         zcpr.next_out = CprPtr;
 202
 203
 204         do
 205         {
 206             long all_read_before = zcpr.total_in;
 207             zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
 208             zcpr.avail_out = BlockSizeCompress;
 209             ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
 210             lOrigDone += (zcpr.total_in-all_read_before);
 211             lOrigToDo -= (zcpr.total_in-all_read_before);
 212             step++;
 213         } while (ret==Z_OK);
 214
 215         lSizeCpr=zcpr.total_out;
 216         deflateEnd(&zcpr);
 217         dwGetTick=GetTickCount()-dwGetTick;
 218         dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
 219         dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
 220         printf("total compress size = %u, in %u step\n",lSizeCpr,step);
 221         printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
 222         printf("defcpr time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
 223         printf("defcpr result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
 224     }
 225
 226     CprPtr=(unsigned char*)realloc(CprPtr,lSizeCpr);
 227     UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
 228
 229     BeginCountPerfCounter(&li_qp,TRUE);
 230     dwGetTick=GetTickCount();
 231     BeginCountRdtsc(&li_rdtsc);
 232     {
 233         z_stream zcpr;
 234         int ret=Z_OK;
 235         long lOrigToDo = lSizeCpr;
 236         long lOrigDone = 0;
 237         int step=0;
 238         memset(&zcpr,0,sizeof(z_stream));
 239         inflateInit(&zcpr);
 240
 241         zcpr.next_in = CprPtr;
 242         zcpr.next_out = UncprPtr;
 243
 244
 245         do
 246         {
 247             long all_read_before = zcpr.total_in;
 248             zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
 249             zcpr.avail_out = BlockSizeUncompress;
 250             ret=inflate(&zcpr,Z_SYNC_FLUSH);
 251             lOrigDone += (zcpr.total_in-all_read_before);
 252             lOrigToDo -= (zcpr.total_in-all_read_before);
 253             step++;
 254         } while (ret==Z_OK);
 255
 256         lSizeUncpr=zcpr.total_out;
 257         inflateEnd(&zcpr);
 258         dwGetTick=GetTickCount()-dwGetTick;
 259         dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
 260         dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
 261         printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
 262         printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
 263         printf("uncpr  time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
 264         printf("uncpr  result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
 265     }
 266
 267     if (lSizeUncpr==lFileSize)
 268     {
 269         if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
 270             printf("compare ok\n");
 271
 272     }
 273
 274     return 0;
 275 }