• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <windows.h>
4 
5 #include "zlib.h"
6 
7 
MyDoMinus64(LARGE_INTEGER * R,LARGE_INTEGER A,LARGE_INTEGER B)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);
BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)23 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
24 {
25  //   printf("rdtsc = %I64x\n",__rdtsc());
26    pbeginTime64->QuadPart=__rdtsc();
27 }
28 
GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)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
myGetRDTSC32(LARGE_INTEGER * pbeginTime64)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 
BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)52 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
53 {
54     myGetRDTSC32(pbeginTime64);
55 }
56 
GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)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
myGetRDTSC32(LARGE_INTEGER * pbeginTime64)67 void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
68 {
69 }
70 
BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)71 void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
72 {
73 }
74 
GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)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 
BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)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 
GetMsecSincePerfCounter(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)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 
ReadFileMemory(const char * filename,long * plFileSize,unsigned char ** pFilePtr)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 
main(int argc,char * argv[])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 }
276