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