root/lib/zlib/contrib/testzlib/testzlib.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. MyDoMinus64
  2. BeginCountRdtsc
  3. GetResRdtsc
  4. myGetRDTSC32
  5. BeginCountRdtsc
  6. GetResRdtsc
  7. myGetRDTSC32
  8. BeginCountRdtsc
  9. GetResRdtsc
  10. BeginCountPerfCounter
  11. GetMsecSincePerfCounter
  12. ReadFileMemory
  13. main

   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)
     /* [<][>][^][v][top][bottom][index][help] */
   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)
     /* [<][>][^][v][top][bottom][index][help] */
  24 {
  25  //   printf("rdtsc = %I64x\n",__rdtsc());

  26    pbeginTime64->QuadPart=__rdtsc();
  27 }
  28 
  29 LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
  53 {
  54     myGetRDTSC32(pbeginTime64);
  55 }
  56 
  57 LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
  68 {
  69 }
  70 
  71 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
     /* [<][>][^][v][top][bottom][index][help] */
  72 {
  73 }
  74 
  75 LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
  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,void** pFilePtr)
     /* [<][>][^][v][top][bottom][index][help] */
 120 {
 121     FILE* stream;
 122     void* 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[])
     /* [<][>][^][v][top][bottom][index][help] */
 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 }

/* [<][>][^][v][top][bottom][index][help] */