• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

contrib/zlib/contrib/testzlib/testzlib.c

00001 #include <stdio.h>
00002 #include <stdlib.h>
00003 #include <windows.h>
00004 
00005 #include "zlib.h"
00006 
00007 
00008 void MyDoMinus64(LARGE_INTEGER *R,LARGE_INTEGER A,LARGE_INTEGER B)
00009 {
00010     R->HighPart = A.HighPart - B.HighPart;
00011     if (A.LowPart >= B.LowPart)
00012         R->LowPart = A.LowPart - B.LowPart;
00013     else
00014     {
00015         R->LowPart = A.LowPart - B.LowPart;
00016         R->HighPart --;
00017     }
00018 }
00019 
00020 #ifdef _M_X64
00021 // see http://msdn2.microsoft.com/library/twchhe95(en-us,vs.80).aspx for __rdtsc
00022 unsigned __int64 __rdtsc(void);
00023 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
00024 {
00025  //   printf("rdtsc = %I64x\n",__rdtsc());
00026    pbeginTime64->QuadPart=__rdtsc();
00027 }
00028 
00029 LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
00030 {
00031     LARGE_INTEGER LIres;
00032     unsigned _int64 res=__rdtsc()-((unsigned _int64)(beginTime64.QuadPart));
00033     LIres.QuadPart=res;
00034    // printf("rdtsc = %I64x\n",__rdtsc());
00035     return LIres;
00036 }
00037 #else
00038 #ifdef _M_IX86
00039 void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
00040 {
00041     DWORD dwEdx,dwEax;
00042     _asm
00043     {
00044         rdtsc
00045         mov dwEax,eax
00046         mov dwEdx,edx
00047     }
00048     pbeginTime64->LowPart=dwEax;
00049     pbeginTime64->HighPart=dwEdx;
00050 }
00051 
00052 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
00053 {
00054     myGetRDTSC32(pbeginTime64);
00055 }
00056 
00057 LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
00058 {
00059     LARGE_INTEGER LIres,endTime64;
00060     myGetRDTSC32(&endTime64);
00061 
00062     LIres.LowPart=LIres.HighPart=0;
00063     MyDoMinus64(&LIres,endTime64,beginTime64);
00064     return LIres;
00065 }
00066 #else
00067 void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
00068 {
00069 }
00070 
00071 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
00072 {
00073 }
00074 
00075 LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
00076 {
00077     LARGE_INTEGER lr;
00078     lr.QuadPart=0;
00079     return lr;
00080 }
00081 #endif
00082 #endif
00083 
00084 void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
00085 {
00086     if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
00087     {
00088         pbeginTime64->LowPart = GetTickCount();
00089         pbeginTime64->HighPart = 0;
00090     }
00091 }
00092 
00093 DWORD GetMsecSincePerfCounter(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
00094 {
00095     LARGE_INTEGER endTime64,ticksPerSecond,ticks;
00096     DWORDLONG ticksShifted,tickSecShifted;
00097     DWORD dwLog=16+0;
00098     DWORD dwRet;
00099     if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(&endTime64)))
00100         dwRet = (GetTickCount() - beginTime64.LowPart)*1;
00101     else
00102     {
00103         MyDoMinus64(&ticks,endTime64,beginTime64);
00104         QueryPerformanceFrequency(&ticksPerSecond);
00105 
00106 
00107         {
00108             ticksShifted = Int64ShrlMod32(*(DWORDLONG*)&ticks,dwLog);
00109             tickSecShifted = Int64ShrlMod32(*(DWORDLONG*)&ticksPerSecond,dwLog);
00110 
00111         }
00112 
00113         dwRet = (DWORD)((((DWORD)ticksShifted)*1000)/(DWORD)(tickSecShifted));
00114         dwRet *=1;
00115     }
00116     return dwRet;
00117 }
00118 
00119 int ReadFileMemory(const char* filename,long* plFileSize,void** pFilePtr)
00120 {
00121     FILE* stream;
00122     void* ptr;
00123     int retVal=1;
00124     stream=fopen(filename, "rb");
00125     if (stream==NULL)
00126         return 0;
00127 
00128     fseek(stream,0,SEEK_END);
00129 
00130     *plFileSize=ftell(stream);
00131     fseek(stream,0,SEEK_SET);
00132     ptr=malloc((*plFileSize)+1);
00133     if (ptr==NULL)
00134         retVal=0;
00135     else
00136     {
00137         if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize))
00138             retVal=0;
00139     }
00140     fclose(stream);
00141     *pFilePtr=ptr;
00142     return retVal;
00143 }
00144 
00145 int main(int argc, char *argv[])
00146 {
00147     int BlockSizeCompress=0x8000;
00148     int BlockSizeUncompress=0x8000;
00149     int cprLevel=Z_DEFAULT_COMPRESSION ;
00150     long lFileSize;
00151     unsigned char* FilePtr;
00152     long lBufferSizeCpr;
00153     long lBufferSizeUncpr;
00154     long lCompressedSize=0;
00155     unsigned char* CprPtr;
00156     unsigned char* UncprPtr;
00157     long lSizeCpr,lSizeUncpr;
00158     DWORD dwGetTick,dwMsecQP;
00159     LARGE_INTEGER li_qp,li_rdtsc,dwResRdtsc;
00160 
00161     if (argc<=1)
00162     {
00163         printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
00164         return 0;
00165     }
00166 
00167     if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
00168     {
00169         printf("error reading %s\n",argv[1]);
00170         return 1;
00171     }
00172     else printf("file %s read, %u bytes\n",argv[1],lFileSize);
00173 
00174     if (argc>=3)
00175         BlockSizeCompress=atol(argv[2]);
00176 
00177     if (argc>=4)
00178         BlockSizeUncompress=atol(argv[3]);
00179 
00180     if (argc>=5)
00181         cprLevel=(int)atol(argv[4]);
00182 
00183     lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
00184     lBufferSizeUncpr = lBufferSizeCpr;
00185 
00186     CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
00187 
00188     BeginCountPerfCounter(&li_qp,TRUE);
00189     dwGetTick=GetTickCount();
00190     BeginCountRdtsc(&li_rdtsc);
00191     {
00192         z_stream zcpr;
00193         int ret=Z_OK;
00194         long lOrigToDo = lFileSize;
00195         long lOrigDone = 0;
00196         int step=0;
00197         memset(&zcpr,0,sizeof(z_stream));
00198         deflateInit(&zcpr,cprLevel);
00199 
00200         zcpr.next_in = FilePtr;
00201         zcpr.next_out = CprPtr;
00202 
00203 
00204         do
00205         {
00206             long all_read_before = zcpr.total_in;
00207             zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
00208             zcpr.avail_out = BlockSizeCompress;
00209             ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
00210             lOrigDone += (zcpr.total_in-all_read_before);
00211             lOrigToDo -= (zcpr.total_in-all_read_before);
00212             step++;
00213         } while (ret==Z_OK);
00214 
00215         lSizeCpr=zcpr.total_out;
00216         deflateEnd(&zcpr);
00217         dwGetTick=GetTickCount()-dwGetTick;
00218         dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
00219         dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
00220         printf("total compress size = %u, in %u step\n",lSizeCpr,step);
00221         printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
00222         printf("defcpr time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
00223         printf("defcpr result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
00224     }
00225 
00226     CprPtr=(unsigned char*)realloc(CprPtr,lSizeCpr);
00227     UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
00228 
00229     BeginCountPerfCounter(&li_qp,TRUE);
00230     dwGetTick=GetTickCount();
00231     BeginCountRdtsc(&li_rdtsc);
00232     {
00233         z_stream zcpr;
00234         int ret=Z_OK;
00235         long lOrigToDo = lSizeCpr;
00236         long lOrigDone = 0;
00237         int step=0;
00238         memset(&zcpr,0,sizeof(z_stream));
00239         inflateInit(&zcpr);
00240 
00241         zcpr.next_in = CprPtr;
00242         zcpr.next_out = UncprPtr;
00243 
00244 
00245         do
00246         {
00247             long all_read_before = zcpr.total_in;
00248             zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
00249             zcpr.avail_out = BlockSizeUncompress;
00250             ret=inflate(&zcpr,Z_SYNC_FLUSH);
00251             lOrigDone += (zcpr.total_in-all_read_before);
00252             lOrigToDo -= (zcpr.total_in-all_read_before);
00253             step++;
00254         } while (ret==Z_OK);
00255 
00256         lSizeUncpr=zcpr.total_out;
00257         inflateEnd(&zcpr);
00258         dwGetTick=GetTickCount()-dwGetTick;
00259         dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
00260         dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
00261         printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
00262         printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
00263         printf("uncpr  time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
00264         printf("uncpr  result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
00265     }
00266 
00267     if (lSizeUncpr==lFileSize)
00268     {
00269         if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
00270             printf("compare ok\n");
00271 
00272     }
00273 
00274     return 0;
00275 }

Generated on Wed Oct 20 2010 11:12:17 for APBS by  doxygen 1.7.2