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
00022 unsigned __int64 __rdtsc(void);
00023 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
00024 {
00025
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
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 }