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