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
10void 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
24unsigned __int64 __rdtsc(void);
25void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
26{
27 //   printf("rdtsc = %I64x\n",__rdtsc());
28   pbeginTime64->QuadPart=__rdtsc();
29}
30
31LARGE_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
41void 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
54void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
55{
56    myGetRDTSC32(pbeginTime64);
57}
58
59LARGE_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
69void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
70{
71}
72
73void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
74{
75}
76
77LARGE_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
86void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
87{
88    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
89    {
90        pbeginTime64->LowPart = GetTickCount();
91        pbeginTime64->HighPart = 0;
92    }
93}
94
95DWORD 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
121int 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
147int 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