testzlib.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "zlib.h"

Go to the source code of this file.

Functions
void	MyDoMinus64 (LARGE_INTEGER *R, LARGE_INTEGER A, LARGE_INTEGER B)
void	myGetRDTSC32 (LARGE_INTEGER *pbeginTime64)
void	BeginCountRdtsc (LARGE_INTEGER *pbeginTime64)
LARGE_INTEGER	GetResRdtsc (LARGE_INTEGER beginTime64, BOOL fComputeTimeQueryPerf)
void	BeginCountPerfCounter (LARGE_INTEGER *pbeginTime64, BOOL fComputeTimeQueryPerf)
DWORD	GetMsecSincePerfCounter (LARGE_INTEGER beginTime64, BOOL fComputeTimeQueryPerf)
int	ReadFileMemory (const char *filename, long *plFileSize, unsigned char **pFilePtr)
int	main (int argc, char *argv[])

Function Documentation

BeginCountPerfCounter()

void BeginCountPerfCounter	(	LARGE_INTEGER *	pbeginTime64,
		BOOL	fComputeTimeQueryPerf
	)

Definition at line 84 of file testzlib.c.

{
    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
    {
        pbeginTime64->LowPart = GetTickCount();
        pbeginTime64->HighPart = 0;
    }
}

Referenced by main().

BeginCountRdtsc()

void BeginCountRdtsc

(

LARGE_INTEGER *

pbeginTime64

)

Definition at line 71 of file testzlib.c.

{
}

Referenced by main().

GetMsecSincePerfCounter()

DWORD GetMsecSincePerfCounter	(	LARGE_INTEGER	beginTime64,
		BOOL	fComputeTimeQueryPerf
	)

Definition at line 93 of file testzlib.c.

{
    LARGE_INTEGER endTime64,ticksPerSecond,ticks;
    DWORDLONG ticksShifted,tickSecShifted;
    DWORD dwLog=16+0;
    DWORD dwRet;
    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(&endTime64)))
        dwRet = (GetTickCount() - beginTime64.LowPart)*1;
    else
    {
        MyDoMinus64(&ticks,endTime64,beginTime64);
        QueryPerformanceFrequency(&ticksPerSecond);
 
 
        {
            ticksShifted = Int64ShrlMod32(*(DWORDLONG*)&ticks,dwLog);
            tickSecShifted = Int64ShrlMod32(*(DWORDLONG*)&ticksPerSecond,dwLog);
 
        }
 
        dwRet = (DWORD)((((DWORD)ticksShifted)*1000)/(DWORD)(tickSecShifted));
        dwRet *=1;
    }
    return dwRet;
}

References DWORD, and MyDoMinus64().

Referenced by main().

GetResRdtsc()

LARGE_INTEGER GetResRdtsc	(	LARGE_INTEGER	beginTime64,
		BOOL	fComputeTimeQueryPerf
	)

Definition at line 75 of file testzlib.c.

{
    LARGE_INTEGER lr;
    lr.QuadPart=0;
    return lr;
}

References lr.

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 145 of file testzlib.c.

{
    int BlockSizeCompress=0x8000;
    int BlockSizeUncompress=0x8000;
    int cprLevel=Z_DEFAULT_COMPRESSION ;
    long lFileSize;
    unsigned char* FilePtr;
    long lBufferSizeCpr;
    long lBufferSizeUncpr;
    long lCompressedSize=0;
    unsigned char* CprPtr;
    unsigned char* UncprPtr;
    long lSizeCpr,lSizeUncpr;
    DWORD dwGetTick,dwMsecQP;
    LARGE_INTEGER li_qp,li_rdtsc,dwResRdtsc;
 
    if (argc<=1)
    {
        printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
        return 0;
    }
 
    if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
    {
        printf("error reading %s\n",argv[1]);
        return 1;
    }
    else printf("file %s read, %u bytes\n",argv[1],lFileSize);
 
    if (argc>=3)
        BlockSizeCompress=atol(argv[2]);
 
    if (argc>=4)
        BlockSizeUncompress=atol(argv[3]);
 
    if (argc>=5)
        cprLevel=(int)atol(argv[4]);
 
    lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
    lBufferSizeUncpr = lBufferSizeCpr;
 
    CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
 
    BeginCountPerfCounter(&li_qp,TRUE);
    dwGetTick=GetTickCount();
    BeginCountRdtsc(&li_rdtsc);
    {
        z_stream zcpr;
        int ret=Z_OK;
        long lOrigToDo = lFileSize;
        long lOrigDone = 0;
        int step=0;
        memset(&zcpr,0,sizeof(z_stream));
        deflateInit(&zcpr,cprLevel);
 
        zcpr.next_in = FilePtr;
        zcpr.next_out = CprPtr;
 
 
        do
        {
            long all_read_before = zcpr.total_in;
            zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
            zcpr.avail_out = BlockSizeCompress;
            ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
            lOrigDone += (zcpr.total_in-all_read_before);
            lOrigToDo -= (zcpr.total_in-all_read_before);
            step++;
        } while (ret==Z_OK);
 
        lSizeCpr=zcpr.total_out;
        deflateEnd(&zcpr);
        dwGetTick=GetTickCount()-dwGetTick;
        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
        printf("total compress size = %u, in %u step\n",lSizeCpr,step);
        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
        printf("defcpr time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
        printf("defcpr result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
    }
 
    CprPtr=(unsigned char*)realloc(CprPtr,lSizeCpr);
    UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
 
    BeginCountPerfCounter(&li_qp,TRUE);
    dwGetTick=GetTickCount();
    BeginCountRdtsc(&li_rdtsc);
    {
        z_stream zcpr;
        int ret=Z_OK;
        long lOrigToDo = lSizeCpr;
        long lOrigDone = 0;
        int step=0;
        memset(&zcpr,0,sizeof(z_stream));
        inflateInit(&zcpr);
 
        zcpr.next_in = CprPtr;
        zcpr.next_out = UncprPtr;
 
 
        do
        {
            long all_read_before = zcpr.total_in;
            zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
            zcpr.avail_out = BlockSizeUncompress;
            ret=inflate(&zcpr,Z_SYNC_FLUSH);
            lOrigDone += (zcpr.total_in-all_read_before);
            lOrigToDo -= (zcpr.total_in-all_read_before);
            step++;
        } while (ret==Z_OK);
 
        lSizeUncpr=zcpr.total_out;
        inflateEnd(&zcpr);
        dwGetTick=GetTickCount()-dwGetTick;
        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
        printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
        printf("uncpr  time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
        printf("uncpr  result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
    }
 
    if (lSizeUncpr==lFileSize)
    {
        if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
            printf("compare ok\n");
 
    }
 
    return 0;
}

References argv, z_stream_s::avail_in, z_stream_s::avail_out, BeginCountPerfCounter(), BeginCountRdtsc(), deflate(), deflateEnd(), deflateInit, DWORD, GetMsecSincePerfCounter(), GetResRdtsc(), inflate(), inflateEnd(), inflateInit, int, malloc(), memset(), min, z_stream_s::next_in, z_stream_s::next_out, printf(), ReadFileMemory(), realloc(), step(), z_stream_s::total_in, z_stream_s::total_out, TRUE, Z_DEFAULT_COMPRESSION, Z_FINISH, Z_OK, and Z_SYNC_FLUSH.

MyDoMinus64()

void MyDoMinus64	(	LARGE_INTEGER *	R,
		LARGE_INTEGER	A,
		LARGE_INTEGER	B
	)

Definition at line 8 of file testzlib.c.

{
    R->HighPart = A.HighPart - B.HighPart;
    if (A.LowPart >= B.LowPart)
        R->LowPart = A.LowPart - B.LowPart;
    else
    {
        R->LowPart = A.LowPart - B.LowPart;
        R->HighPart --;
    }
}

References A, B, and R.

Referenced by GetMsecSincePerfCounter().

myGetRDTSC32()

void myGetRDTSC32

(

LARGE_INTEGER *

pbeginTime64

)

Definition at line 67 of file testzlib.c.

{
}

ReadFileMemory()

int ReadFileMemory	(	const char *	filename,
		long *	plFileSize,
		unsigned char **	pFilePtr
	)

Definition at line 119 of file testzlib.c.

{
    FILE* stream;
    unsigned char* ptr;
    int retVal=1;
    stream=fopen(filename, "rb");
    if (stream==NULL)
        return 0;
 
    fseek(stream,0,SEEK_END);
 
    *plFileSize=ftell(stream);
    fseek(stream,0,SEEK_SET);
    ptr=malloc((*plFileSize)+1);
    if (ptr==NULL)
        retVal=0;
    else
    {
        if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize))
            retVal=0;
    }
    fclose(stream);
    *pFilePtr=ptr;
    return retVal;
}

References benchmark::FILE, malloc(), NULL, SEEK_END, and SEEK_SET.

Referenced by main().