]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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) | |
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) | |
24 | { | |
25 | // printf("rdtsc = %I64x\n",__rdtsc()); | |
26 | pbeginTime64->QuadPart=__rdtsc(); | |
27 | } | |
28 | ||
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 | |
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 | ||
52 | void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64) | |
53 | { | |
54 | myGetRDTSC32(pbeginTime64); | |
55 | } | |
56 | ||
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 | |
67 | void myGetRDTSC32(LARGE_INTEGER * pbeginTime64) | |
68 | { | |
69 | } | |
70 | ||
71 | void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64) | |
72 | { | |
73 | } | |
74 | ||
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 | ||
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 | ||
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 | ||
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 | ||
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 | } |