source: s10k/CommonLibs/zlib-1.2.8/contrib/testzlib/testzlib.c @ 1096

Last change on this file since 1096 was 1096, checked in by s10k, 19 months ago

Added zlib, quazip, basicxmlsyntaxhighlighter, conditionalsemaphore and linenumberdisplay libraries. zlib and quazip are pre-compiled, but you can compile them yourself, just delete the dll files (or equivalent binary files to your OS)

File size: 7.5 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <windows.h>
4
5#include "zlib.h"
6
7
8void 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
22unsigned __int64 __rdtsc(void);
23void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
24{
25 //   printf("rdtsc = %I64x\n",__rdtsc());
26   pbeginTime64->QuadPart=__rdtsc();
27}
28
29LARGE_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
39void 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
52void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
53{
54    myGetRDTSC32(pbeginTime64);
55}
56
57LARGE_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
67void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
68{
69}
70
71void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
72{
73}
74
75LARGE_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
84void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
85{
86    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
87    {
88        pbeginTime64->LowPart = GetTickCount();
89        pbeginTime64->HighPart = 0;
90    }
91}
92
93DWORD 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
119int 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
145int 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}
Note: See TracBrowser for help on using the repository browser.